2019-05-29 23:57:49 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2010-10-23 03:53:03 +00:00
|
|
|
/*
|
|
|
|
* turbostat -- show CPU frequency and C-state residency
|
2018-08-08 00:22:28 +00:00
|
|
|
* on modern Intel and AMD processors.
|
2010-10-23 03:53:03 +00:00
|
|
|
*
|
2013-11-09 05:30:16 +00:00
|
|
|
* Copyright (c) 2013 Intel Corporation.
|
2010-10-23 03:53:03 +00:00
|
|
|
* Len Brown <len.brown@intel.com>
|
|
|
|
*/
|
|
|
|
|
2012-03-30 01:44:40 +00:00
|
|
|
#define _GNU_SOURCE
|
turbostat: Don't put unprocessed uapi headers in the include path
turbostat's Makefile puts arch/x86/include/uapi/ in the include path, so
that it can include <asm/msr.h> from it. It isn't in general safe to
include even uapi headers directly from the kernel tree without
processing them through scripts/headers_install.sh, but asm/msr.h
happens to work.
However, that include path can break with some versions of system
headers, by overriding some system headers with the unprocessed versions
directly from the kernel source. For instance:
In file included from /build/x86-generic/usr/include/bits/sigcontext.h:28:0,
from /build/x86-generic/usr/include/signal.h:339,
from /build/x86-generic/usr/include/sys/wait.h:31,
from turbostat.c:27:
../../../../arch/x86/include/uapi/asm/sigcontext.h:4:28: fatal error: linux/compiler.h: No such file or directory
This occurs because the system bits/sigcontext.h on that build system
includes <asm/sigcontext.h>, and asm/sigcontext.h in the kernel source
includes <linux/compiler.h>, which scripts/headers_install.sh would have
filtered out.
Since turbostat really only wants a single header, just include that one
header rather than putting an entire directory of kernel headers on the
include path.
In the process, switch from msr.h to msr-index.h, since turbostat just
wants the MSR numbers.
Signed-off-by: Josh Triplett <josh@joshtriplett.org>
Cc: stable@vger.kernel.org
Signed-off-by: Len Brown <len.brown@intel.com>
2013-08-21 00:20:12 +00:00
|
|
|
#include MSRHEADER
|
2016-06-17 03:22:37 +00:00
|
|
|
#include INTEL_FAMILY_HEADER
|
2013-08-21 00:20:16 +00:00
|
|
|
#include <stdarg.h>
|
2010-10-23 03:53:03 +00:00
|
|
|
#include <stdio.h>
|
2013-08-21 00:20:18 +00:00
|
|
|
#include <err.h>
|
2010-10-23 03:53:03 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <sys/stat.h>
|
2017-07-19 23:28:37 +00:00
|
|
|
#include <sys/select.h>
|
2010-10-23 03:53:03 +00:00
|
|
|
#include <sys/resource.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <stdlib.h>
|
2015-02-10 06:56:38 +00:00
|
|
|
#include <getopt.h>
|
2010-10-23 03:53:03 +00:00
|
|
|
#include <dirent.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
2012-03-30 01:44:40 +00:00
|
|
|
#include <sched.h>
|
2016-02-13 03:44:48 +00:00
|
|
|
#include <time.h>
|
2013-08-21 00:20:14 +00:00
|
|
|
#include <cpuid.h>
|
2014-08-15 04:36:50 +00:00
|
|
|
#include <linux/capability.h>
|
|
|
|
#include <errno.h>
|
2018-08-17 16:34:41 +00:00
|
|
|
#include <math.h>
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
char *proc_stat = "/proc/stat";
|
2016-02-14 04:36:17 +00:00
|
|
|
FILE *outf;
|
2016-02-27 01:51:02 +00:00
|
|
|
int *fd_percpu;
|
2017-07-19 23:28:37 +00:00
|
|
|
struct timeval interval_tv = {5, 0};
|
2017-10-04 12:01:47 +00:00
|
|
|
struct timespec interval_ts = {5, 0};
|
2017-07-19 23:28:37 +00:00
|
|
|
struct timespec one_msec = {0, 1000000};
|
2018-04-26 00:41:03 +00:00
|
|
|
unsigned int num_iterations;
|
2015-02-10 06:56:38 +00:00
|
|
|
unsigned int debug;
|
2017-01-21 07:26:00 +00:00
|
|
|
unsigned int quiet;
|
2017-10-17 19:42:56 +00:00
|
|
|
unsigned int shown;
|
2017-02-16 02:45:40 +00:00
|
|
|
unsigned int sums_need_wide_columns;
|
2015-02-10 06:56:38 +00:00
|
|
|
unsigned int rapl_joules;
|
|
|
|
unsigned int summary_only;
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
unsigned int list_header_only;
|
2015-02-10 06:56:38 +00:00
|
|
|
unsigned int dump_only;
|
2010-10-23 03:53:03 +00:00
|
|
|
unsigned int do_snb_cstates;
|
2015-05-20 16:49:34 +00:00
|
|
|
unsigned int do_knl_cstates;
|
2013-11-09 05:30:16 +00:00
|
|
|
unsigned int do_slm_cstates;
|
|
|
|
unsigned int use_c1_residency_msr;
|
2010-10-23 03:53:03 +00:00
|
|
|
unsigned int has_aperf;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
unsigned int has_epb;
|
2016-04-06 21:15:55 +00:00
|
|
|
unsigned int do_irtl_snb;
|
|
|
|
unsigned int do_irtl_hsw;
|
2014-02-06 05:55:19 +00:00
|
|
|
unsigned int units = 1000000; /* MHz etc */
|
2010-10-23 03:53:03 +00:00
|
|
|
unsigned int genuine_intel;
|
2018-08-08 00:22:28 +00:00
|
|
|
unsigned int authentic_amd;
|
|
|
|
unsigned int max_level, max_extended_level;
|
2010-10-23 03:53:03 +00:00
|
|
|
unsigned int has_invariant_tsc;
|
2015-01-23 05:12:33 +00:00
|
|
|
unsigned int do_nhm_platform_info;
|
2017-01-01 18:08:33 +00:00
|
|
|
unsigned int no_MSR_MISC_PWR_MGMT;
|
2015-09-14 11:31:00 +00:00
|
|
|
unsigned int aperf_mperf_multiplier = 1;
|
2010-10-23 03:53:03 +00:00
|
|
|
double bclk;
|
2015-09-26 04:12:38 +00:00
|
|
|
double base_hz;
|
2015-10-20 02:37:40 +00:00
|
|
|
unsigned int has_base_hz;
|
2015-09-26 04:12:38 +00:00
|
|
|
double tsc_tweak = 1.0;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
unsigned int show_pkg_only;
|
|
|
|
unsigned int show_core_only;
|
|
|
|
char *output_buffer, *outp;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
unsigned int do_rapl;
|
|
|
|
unsigned int do_dts;
|
|
|
|
unsigned int do_ptm;
|
2016-02-27 06:28:12 +00:00
|
|
|
unsigned long long gfx_cur_rc6_ms;
|
2018-06-01 16:35:53 +00:00
|
|
|
unsigned long long cpuidle_cur_cpu_lpi_us;
|
|
|
|
unsigned long long cpuidle_cur_sys_lpi_us;
|
2016-02-27 05:37:54 +00:00
|
|
|
unsigned int gfx_cur_mhz;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
unsigned int tcc_activation_temp;
|
|
|
|
unsigned int tcc_activation_temp_override;
|
2014-12-05 05:07:00 +00:00
|
|
|
double rapl_power_units, rapl_time_units;
|
|
|
|
double rapl_dram_energy_units, rapl_energy_units;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
double rapl_joule_counter_range;
|
2014-08-15 06:39:52 +00:00
|
|
|
unsigned int do_core_perf_limit_reasons;
|
2017-09-05 12:14:08 +00:00
|
|
|
unsigned int has_automatic_cstate_conversion;
|
2014-08-15 06:39:52 +00:00
|
|
|
unsigned int do_gfx_perf_limit_reasons;
|
|
|
|
unsigned int do_ring_perf_limit_reasons;
|
2015-04-02 01:02:57 +00:00
|
|
|
unsigned int crystal_hz;
|
|
|
|
unsigned long long tsc_hz;
|
2015-05-25 12:34:28 +00:00
|
|
|
int base_cpu;
|
2015-10-20 02:37:40 +00:00
|
|
|
double discover_bclk(unsigned int family, unsigned int model);
|
2015-12-01 06:36:39 +00:00
|
|
|
unsigned int has_hwp; /* IA32_PM_ENABLE, IA32_HWP_CAPABILITIES */
|
|
|
|
/* IA32_HWP_REQUEST, IA32_HWP_STATUS */
|
|
|
|
unsigned int has_hwp_notify; /* IA32_HWP_INTERRUPT */
|
|
|
|
unsigned int has_hwp_activity_window; /* IA32_HWP_REQUEST[bits 41:32] */
|
|
|
|
unsigned int has_hwp_epp; /* IA32_HWP_REQUEST[bits 31:24] */
|
|
|
|
unsigned int has_hwp_pkg; /* IA32_HWP_REQUEST_PKG */
|
2017-01-21 06:26:16 +00:00
|
|
|
unsigned int has_misc_feature_control;
|
2018-06-06 21:44:48 +00:00
|
|
|
unsigned int first_counter_read = 1;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2013-12-03 07:19:19 +00:00
|
|
|
#define RAPL_PKG (1 << 0)
|
|
|
|
/* 0x610 MSR_PKG_POWER_LIMIT */
|
|
|
|
/* 0x611 MSR_PKG_ENERGY_STATUS */
|
|
|
|
#define RAPL_PKG_PERF_STATUS (1 << 1)
|
|
|
|
/* 0x613 MSR_PKG_PERF_STATUS */
|
|
|
|
#define RAPL_PKG_POWER_INFO (1 << 2)
|
|
|
|
/* 0x614 MSR_PKG_POWER_INFO */
|
|
|
|
|
|
|
|
#define RAPL_DRAM (1 << 3)
|
|
|
|
/* 0x618 MSR_DRAM_POWER_LIMIT */
|
|
|
|
/* 0x619 MSR_DRAM_ENERGY_STATUS */
|
|
|
|
#define RAPL_DRAM_PERF_STATUS (1 << 4)
|
|
|
|
/* 0x61b MSR_DRAM_PERF_STATUS */
|
2015-03-26 04:50:30 +00:00
|
|
|
#define RAPL_DRAM_POWER_INFO (1 << 5)
|
|
|
|
/* 0x61c MSR_DRAM_POWER_INFO */
|
2013-12-03 07:19:19 +00:00
|
|
|
|
2016-06-16 16:48:20 +00:00
|
|
|
#define RAPL_CORES_POWER_LIMIT (1 << 6)
|
2013-12-03 07:19:19 +00:00
|
|
|
/* 0x638 MSR_PP0_POWER_LIMIT */
|
2015-03-26 04:50:30 +00:00
|
|
|
#define RAPL_CORE_POLICY (1 << 7)
|
2013-12-03 07:19:19 +00:00
|
|
|
/* 0x63a MSR_PP0_POLICY */
|
|
|
|
|
2015-03-26 04:50:30 +00:00
|
|
|
#define RAPL_GFX (1 << 8)
|
2013-12-03 07:19:19 +00:00
|
|
|
/* 0x640 MSR_PP1_POWER_LIMIT */
|
|
|
|
/* 0x641 MSR_PP1_ENERGY_STATUS */
|
|
|
|
/* 0x642 MSR_PP1_POLICY */
|
2016-06-16 16:48:20 +00:00
|
|
|
|
|
|
|
#define RAPL_CORES_ENERGY_STATUS (1 << 9)
|
|
|
|
/* 0x639 MSR_PP0_ENERGY_STATUS */
|
2018-08-17 16:34:41 +00:00
|
|
|
#define RAPL_PER_CORE_ENERGY (1 << 10)
|
|
|
|
/* Indicates cores energy collection is per-core,
|
|
|
|
* not per-package. */
|
|
|
|
#define RAPL_AMD_F17H (1 << 11)
|
|
|
|
/* 0xc0010299 MSR_RAPL_PWR_UNIT */
|
|
|
|
/* 0xc001029a MSR_CORE_ENERGY_STAT */
|
|
|
|
/* 0xc001029b MSR_PKG_ENERGY_STAT */
|
2016-06-16 16:48:20 +00:00
|
|
|
#define RAPL_CORES (RAPL_CORES_ENERGY_STATUS | RAPL_CORES_POWER_LIMIT)
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
#define TJMAX_DEFAULT 100
|
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
/* MSRs that are not yet in the kernel-provided header. */
|
|
|
|
#define MSR_RAPL_PWR_UNIT 0xc0010299
|
|
|
|
#define MSR_CORE_ENERGY_STAT 0xc001029a
|
|
|
|
#define MSR_PKG_ENERGY_STAT 0xc001029b
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
/*
|
|
|
|
* buffer size used by sscanf() for added column names
|
|
|
|
* Usually truncated to 7 characters, but also handles 18 columns for raw 64-bit counters
|
|
|
|
*/
|
|
|
|
#define NAME_BYTES 20
|
2017-02-08 07:41:51 +00:00
|
|
|
#define PATH_BYTES 128
|
2016-12-23 04:57:55 +00:00
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
int backwards_count;
|
|
|
|
char *progname;
|
|
|
|
|
2017-02-11 04:54:15 +00:00
|
|
|
#define CPU_SUBSET_MAXCPUS 1024 /* need to use before probe... */
|
|
|
|
cpu_set_t *cpu_present_set, *cpu_affinity_set, *cpu_subset;
|
|
|
|
size_t cpu_present_setsize, cpu_affinity_setsize, cpu_subset_size;
|
2018-06-01 16:38:29 +00:00
|
|
|
#define MAX_ADDED_COUNTERS 8
|
|
|
|
#define MAX_ADDED_THREAD_COUNTERS 24
|
2018-06-02 02:08:58 +00:00
|
|
|
#define BITMASK_SIZE 32
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
struct thread_data {
|
2017-05-28 04:06:55 +00:00
|
|
|
struct timeval tv_begin;
|
|
|
|
struct timeval tv_end;
|
2019-03-25 17:32:42 +00:00
|
|
|
struct timeval tv_delta;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
unsigned long long tsc;
|
|
|
|
unsigned long long aperf;
|
|
|
|
unsigned long long mperf;
|
2013-11-09 05:30:16 +00:00
|
|
|
unsigned long long c1;
|
2017-02-16 02:45:40 +00:00
|
|
|
unsigned long long irq_count;
|
2013-02-10 22:19:24 +00:00
|
|
|
unsigned int smi_count;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
unsigned int cpu_id;
|
2018-06-06 21:44:48 +00:00
|
|
|
unsigned int apic_id;
|
|
|
|
unsigned int x2apic_id;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
unsigned int flags;
|
|
|
|
#define CPU_IS_FIRST_THREAD_IN_CORE 0x2
|
|
|
|
#define CPU_IS_FIRST_CORE_IN_PACKAGE 0x4
|
2018-06-01 16:38:29 +00:00
|
|
|
unsigned long long counter[MAX_ADDED_THREAD_COUNTERS];
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
} *thread_even, *thread_odd;
|
|
|
|
|
|
|
|
struct core_data {
|
|
|
|
unsigned long long c3;
|
|
|
|
unsigned long long c6;
|
|
|
|
unsigned long long c7;
|
2017-02-10 05:27:20 +00:00
|
|
|
unsigned long long mc6_us; /* duplicate as per-core for now, even though per module */
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
unsigned int core_temp_c;
|
2018-08-17 16:34:41 +00:00
|
|
|
unsigned int core_energy; /* MSR_CORE_ENERGY_STAT */
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
unsigned int core_id;
|
2017-02-10 03:22:13 +00:00
|
|
|
unsigned long long counter[MAX_ADDED_COUNTERS];
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
} *core_even, *core_odd;
|
|
|
|
|
|
|
|
struct pkg_data {
|
|
|
|
unsigned long long pc2;
|
|
|
|
unsigned long long pc3;
|
|
|
|
unsigned long long pc6;
|
|
|
|
unsigned long long pc7;
|
2012-11-21 13:22:43 +00:00
|
|
|
unsigned long long pc8;
|
|
|
|
unsigned long long pc9;
|
|
|
|
unsigned long long pc10;
|
2018-06-01 16:35:53 +00:00
|
|
|
unsigned long long cpu_lpi;
|
|
|
|
unsigned long long sys_lpi;
|
2015-03-26 04:50:30 +00:00
|
|
|
unsigned long long pkg_wtd_core_c0;
|
|
|
|
unsigned long long pkg_any_core_c0;
|
|
|
|
unsigned long long pkg_any_gfxe_c0;
|
|
|
|
unsigned long long pkg_both_core_gfxe_c0;
|
2016-04-06 21:16:00 +00:00
|
|
|
long long gfx_rc6_ms;
|
2016-02-27 05:37:54 +00:00
|
|
|
unsigned int gfx_mhz;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
unsigned int package_id;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
unsigned int energy_pkg; /* MSR_PKG_ENERGY_STATUS */
|
|
|
|
unsigned int energy_dram; /* MSR_DRAM_ENERGY_STATUS */
|
|
|
|
unsigned int energy_cores; /* MSR_PP0_ENERGY_STATUS */
|
|
|
|
unsigned int energy_gfx; /* MSR_PP1_ENERGY_STATUS */
|
|
|
|
unsigned int rapl_pkg_perf_status; /* MSR_PKG_PERF_STATUS */
|
|
|
|
unsigned int rapl_dram_perf_status; /* MSR_DRAM_PERF_STATUS */
|
|
|
|
unsigned int pkg_temp_c;
|
2017-02-10 03:22:13 +00:00
|
|
|
unsigned long long counter[MAX_ADDED_COUNTERS];
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
} *package_even, *package_odd;
|
|
|
|
|
|
|
|
#define ODD_COUNTERS thread_odd, core_odd, package_odd
|
|
|
|
#define EVEN_COUNTERS thread_even, core_even, package_even
|
|
|
|
|
2018-06-01 14:04:34 +00:00
|
|
|
#define GET_THREAD(thread_base, thread_no, core_no, node_no, pkg_no) \
|
|
|
|
((thread_base) + \
|
|
|
|
((pkg_no) * \
|
|
|
|
topo.nodes_per_pkg * topo.cores_per_node * topo.threads_per_core) + \
|
|
|
|
((node_no) * topo.cores_per_node * topo.threads_per_core) + \
|
|
|
|
((core_no) * topo.threads_per_core) + \
|
|
|
|
(thread_no))
|
|
|
|
|
|
|
|
#define GET_CORE(core_base, core_no, node_no, pkg_no) \
|
|
|
|
((core_base) + \
|
|
|
|
((pkg_no) * topo.nodes_per_pkg * topo.cores_per_node) + \
|
|
|
|
((node_no) * topo.cores_per_node) + \
|
|
|
|
(core_no))
|
|
|
|
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
#define GET_PKG(pkg_base, pkg_no) (pkg_base + pkg_no)
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
enum counter_scope {SCOPE_CPU, SCOPE_CORE, SCOPE_PACKAGE};
|
2017-02-09 23:25:22 +00:00
|
|
|
enum counter_type {COUNTER_ITEMS, COUNTER_CYCLES, COUNTER_SECONDS, COUNTER_USEC};
|
2016-12-23 04:57:55 +00:00
|
|
|
enum counter_format {FORMAT_RAW, FORMAT_DELTA, FORMAT_PERCENT};
|
|
|
|
|
|
|
|
struct msr_counter {
|
|
|
|
unsigned int msr_num;
|
|
|
|
char name[NAME_BYTES];
|
2017-02-08 07:41:51 +00:00
|
|
|
char path[PATH_BYTES];
|
2016-12-23 04:57:55 +00:00
|
|
|
unsigned int width;
|
|
|
|
enum counter_type type;
|
|
|
|
enum counter_format format;
|
|
|
|
struct msr_counter *next;
|
2017-02-10 05:25:41 +00:00
|
|
|
unsigned int flags;
|
|
|
|
#define FLAGS_HIDE (1 << 0)
|
|
|
|
#define FLAGS_SHOW (1 << 1)
|
2017-02-09 23:25:22 +00:00
|
|
|
#define SYSFS_PERCPU (1 << 1)
|
2016-12-23 04:57:55 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct sys_counters {
|
2017-02-10 03:22:13 +00:00
|
|
|
unsigned int added_thread_counters;
|
|
|
|
unsigned int added_core_counters;
|
|
|
|
unsigned int added_package_counters;
|
2016-12-23 04:57:55 +00:00
|
|
|
struct msr_counter *tp;
|
|
|
|
struct msr_counter *cp;
|
|
|
|
struct msr_counter *pp;
|
|
|
|
} sys;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
struct system_summary {
|
|
|
|
struct thread_data threads;
|
|
|
|
struct core_data cores;
|
|
|
|
struct pkg_data packages;
|
2016-12-23 04:57:55 +00:00
|
|
|
} average;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2018-06-02 02:08:58 +00:00
|
|
|
struct cpu_topology {
|
|
|
|
int physical_package_id;
|
2019-02-15 03:17:40 +00:00
|
|
|
int die_id;
|
2018-06-02 02:08:58 +00:00
|
|
|
int logical_cpu_id;
|
2018-06-01 14:04:30 +00:00
|
|
|
int physical_node_id;
|
|
|
|
int logical_node_id; /* 0-based count within the package */
|
2018-06-02 02:08:58 +00:00
|
|
|
int physical_core_id;
|
2018-06-01 14:04:31 +00:00
|
|
|
int thread_id;
|
2018-06-02 02:08:58 +00:00
|
|
|
cpu_set_t *put_ids; /* Processing Unit/Thread IDs */
|
|
|
|
} *cpus;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
struct topo_params {
|
|
|
|
int num_packages;
|
2019-02-15 03:17:40 +00:00
|
|
|
int num_die;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
int num_cpus;
|
|
|
|
int num_cores;
|
|
|
|
int max_cpu_num;
|
2018-06-01 14:04:30 +00:00
|
|
|
int max_node_num;
|
2018-06-01 14:04:33 +00:00
|
|
|
int nodes_per_pkg;
|
|
|
|
int cores_per_node;
|
|
|
|
int threads_per_core;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
} topo;
|
|
|
|
|
|
|
|
struct timeval tv_even, tv_odd, tv_delta;
|
|
|
|
|
2016-02-27 04:48:05 +00:00
|
|
|
int *irq_column_2_cpu; /* /proc/interrupts column numbers */
|
|
|
|
int *irqs_per_cpu; /* indexed by cpu_num */
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
void setup_all_buffers(void);
|
|
|
|
|
|
|
|
int cpu_is_not_present(int cpu)
|
2012-06-04 03:24:00 +00:00
|
|
|
{
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
|
2012-06-04 03:24:00 +00:00
|
|
|
}
|
2012-03-30 01:44:40 +00:00
|
|
|
/*
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
* run func(thread, core, package) in topology order
|
|
|
|
* skip non-present cpus
|
2012-03-30 01:44:40 +00:00
|
|
|
*/
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
int for_all_cpus(int (func)(struct thread_data *, struct core_data *, struct pkg_data *),
|
|
|
|
struct thread_data *thread_base, struct core_data *core_base, struct pkg_data *pkg_base)
|
2012-03-30 01:44:40 +00:00
|
|
|
{
|
2018-06-01 14:04:34 +00:00
|
|
|
int retval, pkg_no, core_no, thread_no, node_no;
|
2012-06-04 03:24:00 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
|
2019-02-16 05:58:23 +00:00
|
|
|
for (node_no = 0; node_no < topo.nodes_per_pkg; node_no++) {
|
|
|
|
for (core_no = 0; core_no < topo.cores_per_node; ++core_no) {
|
2018-06-01 14:04:34 +00:00
|
|
|
for (thread_no = 0; thread_no <
|
|
|
|
topo.threads_per_core; ++thread_no) {
|
|
|
|
struct thread_data *t;
|
|
|
|
struct core_data *c;
|
|
|
|
struct pkg_data *p;
|
|
|
|
|
|
|
|
t = GET_THREAD(thread_base, thread_no,
|
|
|
|
core_no, node_no,
|
|
|
|
pkg_no);
|
|
|
|
|
|
|
|
if (cpu_is_not_present(t->cpu_id))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
c = GET_CORE(core_base, core_no,
|
|
|
|
node_no, pkg_no);
|
|
|
|
p = GET_PKG(pkg_base, pkg_no);
|
|
|
|
|
|
|
|
retval = func(t, c, p);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
2012-03-30 01:44:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int cpu_migrate(int cpu)
|
|
|
|
{
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
|
|
|
|
CPU_SET_S(cpu, cpu_affinity_setsize, cpu_affinity_set);
|
|
|
|
if (sched_setaffinity(0, cpu_affinity_setsize, cpu_affinity_set) == -1)
|
2012-03-30 01:44:40 +00:00
|
|
|
return -1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-27 01:51:02 +00:00
|
|
|
int get_msr_fd(int cpu)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
|
|
|
char pathname[32];
|
|
|
|
int fd;
|
|
|
|
|
2016-02-27 01:51:02 +00:00
|
|
|
fd = fd_percpu[cpu];
|
|
|
|
|
|
|
|
if (fd)
|
|
|
|
return fd;
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
sprintf(pathname, "/dev/cpu/%d/msr", cpu);
|
|
|
|
fd = open(pathname, O_RDONLY);
|
2012-03-30 02:19:58 +00:00
|
|
|
if (fd < 0)
|
2014-08-15 04:36:50 +00:00
|
|
|
err(-1, "%s open failed, try chown or chmod +r /dev/cpu/*/msr, or run as root", pathname);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2016-02-27 01:51:02 +00:00
|
|
|
fd_percpu[cpu] = fd;
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_msr(int cpu, off_t offset, unsigned long long *msr)
|
|
|
|
{
|
|
|
|
ssize_t retval;
|
|
|
|
|
|
|
|
retval = pread(get_msr_fd(cpu), msr, sizeof(*msr), offset);
|
2012-03-30 02:19:58 +00:00
|
|
|
|
2014-08-15 04:36:50 +00:00
|
|
|
if (retval != sizeof *msr)
|
2017-01-01 18:08:33 +00:00
|
|
|
err(-1, "cpu%d: msr offset 0x%llx read failed", cpu, (unsigned long long)offset);
|
2012-03-30 02:19:58 +00:00
|
|
|
|
|
|
|
return 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2014-02-06 05:55:19 +00:00
|
|
|
/*
|
2018-06-06 21:18:36 +00:00
|
|
|
* This list matches the column headers, except
|
|
|
|
* 1. built-in only, the sysfs counters are not here -- we learn of those at run-time
|
|
|
|
* 2. Core and CPU are moved to the end, we can't have strings that contain them
|
|
|
|
* matching on them for --show and --hide.
|
2014-02-06 05:55:19 +00:00
|
|
|
*/
|
2017-02-10 05:25:41 +00:00
|
|
|
struct msr_counter bic[] = {
|
2017-10-17 19:42:56 +00:00
|
|
|
{ 0x0, "usec" },
|
|
|
|
{ 0x0, "Time_Of_Day_Seconds" },
|
2017-02-10 05:25:41 +00:00
|
|
|
{ 0x0, "Package" },
|
2018-06-06 21:18:36 +00:00
|
|
|
{ 0x0, "Node" },
|
2017-02-10 05:25:41 +00:00
|
|
|
{ 0x0, "Avg_MHz" },
|
2018-06-06 21:18:36 +00:00
|
|
|
{ 0x0, "Busy%" },
|
2017-02-10 05:25:41 +00:00
|
|
|
{ 0x0, "Bzy_MHz" },
|
|
|
|
{ 0x0, "TSC_MHz" },
|
|
|
|
{ 0x0, "IRQ" },
|
2017-02-08 07:41:51 +00:00
|
|
|
{ 0x0, "SMI", "", 32, 0, FORMAT_DELTA, NULL},
|
2018-06-06 21:18:36 +00:00
|
|
|
{ 0x0, "sysfs" },
|
2017-02-10 05:25:41 +00:00
|
|
|
{ 0x0, "CPU%c1" },
|
|
|
|
{ 0x0, "CPU%c3" },
|
|
|
|
{ 0x0, "CPU%c6" },
|
|
|
|
{ 0x0, "CPU%c7" },
|
|
|
|
{ 0x0, "ThreadC" },
|
|
|
|
{ 0x0, "CoreTmp" },
|
|
|
|
{ 0x0, "CoreCnt" },
|
|
|
|
{ 0x0, "PkgTmp" },
|
|
|
|
{ 0x0, "GFX%rc6" },
|
|
|
|
{ 0x0, "GFXMHz" },
|
|
|
|
{ 0x0, "Pkg%pc2" },
|
|
|
|
{ 0x0, "Pkg%pc3" },
|
|
|
|
{ 0x0, "Pkg%pc6" },
|
|
|
|
{ 0x0, "Pkg%pc7" },
|
2017-01-27 05:50:45 +00:00
|
|
|
{ 0x0, "Pkg%pc8" },
|
|
|
|
{ 0x0, "Pkg%pc9" },
|
2018-01-29 04:42:42 +00:00
|
|
|
{ 0x0, "Pk%pc10" },
|
2018-06-01 16:35:53 +00:00
|
|
|
{ 0x0, "CPU%LPI" },
|
|
|
|
{ 0x0, "SYS%LPI" },
|
2017-02-10 05:25:41 +00:00
|
|
|
{ 0x0, "PkgWatt" },
|
|
|
|
{ 0x0, "CorWatt" },
|
|
|
|
{ 0x0, "GFXWatt" },
|
|
|
|
{ 0x0, "PkgCnt" },
|
|
|
|
{ 0x0, "RAMWatt" },
|
|
|
|
{ 0x0, "PKG_%" },
|
|
|
|
{ 0x0, "RAM_%" },
|
|
|
|
{ 0x0, "Pkg_J" },
|
|
|
|
{ 0x0, "Cor_J" },
|
|
|
|
{ 0x0, "GFX_J" },
|
|
|
|
{ 0x0, "RAM_J" },
|
2017-02-10 05:27:20 +00:00
|
|
|
{ 0x0, "Mod%c6" },
|
2017-05-21 00:11:55 +00:00
|
|
|
{ 0x0, "Totl%C0" },
|
|
|
|
{ 0x0, "Any%C0" },
|
|
|
|
{ 0x0, "GFX%C0" },
|
|
|
|
{ 0x0, "CPUGFX%" },
|
2018-06-06 21:18:36 +00:00
|
|
|
{ 0x0, "Core" },
|
|
|
|
{ 0x0, "CPU" },
|
2018-06-06 21:44:48 +00:00
|
|
|
{ 0x0, "APIC" },
|
|
|
|
{ 0x0, "X2APIC" },
|
2019-02-15 03:17:40 +00:00
|
|
|
{ 0x0, "Die" },
|
2017-02-10 05:25:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define MAX_BIC (sizeof(bic) / sizeof(struct msr_counter))
|
2017-10-17 19:42:56 +00:00
|
|
|
#define BIC_USEC (1ULL << 0)
|
|
|
|
#define BIC_TOD (1ULL << 1)
|
|
|
|
#define BIC_Package (1ULL << 2)
|
2018-06-06 21:18:36 +00:00
|
|
|
#define BIC_Node (1ULL << 3)
|
|
|
|
#define BIC_Avg_MHz (1ULL << 4)
|
|
|
|
#define BIC_Busy (1ULL << 5)
|
|
|
|
#define BIC_Bzy_MHz (1ULL << 6)
|
|
|
|
#define BIC_TSC_MHz (1ULL << 7)
|
|
|
|
#define BIC_IRQ (1ULL << 8)
|
|
|
|
#define BIC_SMI (1ULL << 9)
|
|
|
|
#define BIC_sysfs (1ULL << 10)
|
|
|
|
#define BIC_CPU_c1 (1ULL << 11)
|
|
|
|
#define BIC_CPU_c3 (1ULL << 12)
|
|
|
|
#define BIC_CPU_c6 (1ULL << 13)
|
|
|
|
#define BIC_CPU_c7 (1ULL << 14)
|
|
|
|
#define BIC_ThreadC (1ULL << 15)
|
|
|
|
#define BIC_CoreTmp (1ULL << 16)
|
|
|
|
#define BIC_CoreCnt (1ULL << 17)
|
|
|
|
#define BIC_PkgTmp (1ULL << 18)
|
|
|
|
#define BIC_GFX_rc6 (1ULL << 19)
|
|
|
|
#define BIC_GFXMHz (1ULL << 20)
|
|
|
|
#define BIC_Pkgpc2 (1ULL << 21)
|
|
|
|
#define BIC_Pkgpc3 (1ULL << 22)
|
|
|
|
#define BIC_Pkgpc6 (1ULL << 23)
|
|
|
|
#define BIC_Pkgpc7 (1ULL << 24)
|
|
|
|
#define BIC_Pkgpc8 (1ULL << 25)
|
|
|
|
#define BIC_Pkgpc9 (1ULL << 26)
|
|
|
|
#define BIC_Pkgpc10 (1ULL << 27)
|
|
|
|
#define BIC_CPU_LPI (1ULL << 28)
|
|
|
|
#define BIC_SYS_LPI (1ULL << 29)
|
|
|
|
#define BIC_PkgWatt (1ULL << 30)
|
|
|
|
#define BIC_CorWatt (1ULL << 31)
|
|
|
|
#define BIC_GFXWatt (1ULL << 32)
|
|
|
|
#define BIC_PkgCnt (1ULL << 33)
|
|
|
|
#define BIC_RAMWatt (1ULL << 34)
|
|
|
|
#define BIC_PKG__ (1ULL << 35)
|
|
|
|
#define BIC_RAM__ (1ULL << 36)
|
|
|
|
#define BIC_Pkg_J (1ULL << 37)
|
|
|
|
#define BIC_Cor_J (1ULL << 38)
|
|
|
|
#define BIC_GFX_J (1ULL << 39)
|
|
|
|
#define BIC_RAM_J (1ULL << 40)
|
|
|
|
#define BIC_Mod_c6 (1ULL << 41)
|
|
|
|
#define BIC_Totl_c0 (1ULL << 42)
|
|
|
|
#define BIC_Any_c0 (1ULL << 43)
|
|
|
|
#define BIC_GFX_c0 (1ULL << 44)
|
|
|
|
#define BIC_CPUGFX (1ULL << 45)
|
|
|
|
#define BIC_Core (1ULL << 46)
|
|
|
|
#define BIC_CPU (1ULL << 47)
|
2018-06-06 21:44:48 +00:00
|
|
|
#define BIC_APIC (1ULL << 48)
|
|
|
|
#define BIC_X2APIC (1ULL << 49)
|
2019-02-15 03:17:40 +00:00
|
|
|
#define BIC_Die (1ULL << 50)
|
2017-10-17 19:42:56 +00:00
|
|
|
|
2018-06-06 21:44:48 +00:00
|
|
|
#define BIC_DISABLED_BY_DEFAULT (BIC_USEC | BIC_TOD | BIC_APIC | BIC_X2APIC)
|
2017-10-17 19:42:56 +00:00
|
|
|
|
|
|
|
unsigned long long bic_enabled = (0xFFFFFFFFFFFFFFFFULL & ~BIC_DISABLED_BY_DEFAULT);
|
2018-06-06 21:44:48 +00:00
|
|
|
unsigned long long bic_present = BIC_USEC | BIC_TOD | BIC_sysfs | BIC_APIC | BIC_X2APIC;
|
2017-02-10 05:25:41 +00:00
|
|
|
|
|
|
|
#define DO_BIC(COUNTER_NAME) (bic_enabled & bic_present & COUNTER_NAME)
|
2017-10-17 19:42:56 +00:00
|
|
|
#define ENABLE_BIC(COUNTER_NAME) (bic_enabled |= COUNTER_NAME)
|
2017-02-10 05:25:41 +00:00
|
|
|
#define BIC_PRESENT(COUNTER_BIT) (bic_present |= COUNTER_BIT)
|
2017-01-27 05:50:45 +00:00
|
|
|
#define BIC_NOT_PRESENT(COUNTER_BIT) (bic_present &= ~COUNTER_BIT)
|
2017-02-10 05:25:41 +00:00
|
|
|
|
2017-10-17 19:42:56 +00:00
|
|
|
|
2017-02-22 04:21:13 +00:00
|
|
|
#define MAX_DEFERRED 16
|
|
|
|
char *deferred_skip_names[MAX_DEFERRED];
|
|
|
|
int deferred_skip_index;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HIDE_LIST - hide this list of counters, show the rest [default]
|
|
|
|
* SHOW_LIST - show this list of counters, hide the rest
|
|
|
|
*/
|
|
|
|
enum show_hide_mode { SHOW_LIST, HIDE_LIST } global_show_hide_mode = HIDE_LIST;
|
|
|
|
|
|
|
|
void help(void)
|
|
|
|
{
|
|
|
|
fprintf(outf,
|
|
|
|
"Usage: turbostat [OPTIONS][(--interval seconds) | COMMAND ...]\n"
|
|
|
|
"\n"
|
|
|
|
"Turbostat forks the specified COMMAND and prints statistics\n"
|
|
|
|
"when COMMAND completes.\n"
|
|
|
|
"If no COMMAND is specified, turbostat wakes every 5-seconds\n"
|
|
|
|
"to print statistics, until interrupted.\n"
|
2018-06-14 02:51:33 +00:00
|
|
|
" -a, --add add a counter\n"
|
|
|
|
" eg. --add msr0x10,u64,cpu,delta,MY_TSC\n"
|
|
|
|
" -c, --cpu cpu-set limit output to summary plus cpu-set:\n"
|
|
|
|
" {core | package | j,k,l..m,n-p }\n"
|
2018-06-14 02:51:34 +00:00
|
|
|
" -d, --debug displays usec, Time_Of_Day_Seconds and more debugging\n"
|
|
|
|
" -D, --Dump displays the raw counter values\n"
|
|
|
|
" -e, --enable [all | column]\n"
|
|
|
|
" shows all or the specified disabled column\n"
|
|
|
|
" -H, --hide [column|column,column,...]\n"
|
|
|
|
" hide the specified column(s)\n"
|
2018-06-14 02:51:33 +00:00
|
|
|
" -i, --interval sec.subsec\n"
|
|
|
|
" Override default 5-second measurement interval\n"
|
2018-06-14 02:51:34 +00:00
|
|
|
" -J, --Joules displays energy in Joules instead of Watts\n"
|
2018-06-14 02:51:33 +00:00
|
|
|
" -l, --list list column headers only\n"
|
|
|
|
" -n, --num_iterations num\n"
|
|
|
|
" number of the measurement iterations\n"
|
|
|
|
" -o, --out file\n"
|
|
|
|
" create or truncate \"file\" for all output\n"
|
|
|
|
" -q, --quiet skip decoding system configuration header\n"
|
2018-06-14 02:51:34 +00:00
|
|
|
" -s, --show [column|column,column,...]\n"
|
|
|
|
" show only the specified column(s)\n"
|
|
|
|
" -S, --Summary\n"
|
|
|
|
" limits output to 1-line system summary per interval\n"
|
|
|
|
" -T, --TCC temperature\n"
|
|
|
|
" sets the Thermal Control Circuit temperature in\n"
|
|
|
|
" degrees Celsius\n"
|
2018-06-14 02:51:33 +00:00
|
|
|
" -h, --help print this help message\n"
|
|
|
|
" -v, --version print version information\n"
|
2017-02-22 04:21:13 +00:00
|
|
|
"\n"
|
|
|
|
"For more help, run \"man turbostat\"\n");
|
|
|
|
}
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
/*
|
|
|
|
* bic_lookup
|
|
|
|
* for all the strings in comma separate name_list,
|
|
|
|
* set the approprate bit in return value.
|
|
|
|
*/
|
2017-02-22 04:21:13 +00:00
|
|
|
unsigned long long bic_lookup(char *name_list, enum show_hide_mode mode)
|
2017-02-10 05:25:41 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
unsigned long long retval = 0;
|
|
|
|
|
|
|
|
while (name_list) {
|
|
|
|
char *comma;
|
|
|
|
|
|
|
|
comma = strchr(name_list, ',');
|
|
|
|
|
|
|
|
if (comma)
|
|
|
|
*comma = '\0';
|
|
|
|
|
2017-10-17 19:42:56 +00:00
|
|
|
if (!strcmp(name_list, "all"))
|
|
|
|
return ~0;
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
for (i = 0; i < MAX_BIC; ++i) {
|
|
|
|
if (!strcmp(name_list, bic[i].name)) {
|
|
|
|
retval |= (1ULL << i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i == MAX_BIC) {
|
2017-02-22 04:21:13 +00:00
|
|
|
if (mode == SHOW_LIST) {
|
|
|
|
fprintf(stderr, "Invalid counter name: %s\n", name_list);
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
deferred_skip_names[deferred_skip_index++] = name_list;
|
|
|
|
if (debug)
|
|
|
|
fprintf(stderr, "deferred \"%s\"\n", name_list);
|
|
|
|
if (deferred_skip_index >= MAX_DEFERRED) {
|
|
|
|
fprintf(stderr, "More than max %d un-recognized --skip options '%s'\n",
|
|
|
|
MAX_DEFERRED, name_list);
|
|
|
|
help();
|
|
|
|
exit(1);
|
|
|
|
}
|
2017-02-10 05:25:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
name_list = comma;
|
|
|
|
if (name_list)
|
|
|
|
name_list++;
|
|
|
|
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
2014-02-06 05:55:19 +00:00
|
|
|
|
2017-02-22 04:21:13 +00:00
|
|
|
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
void print_header(char *delim)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2016-12-23 04:57:55 +00:00
|
|
|
struct msr_counter *mp;
|
2017-02-17 04:07:51 +00:00
|
|
|
int printed = 0;
|
2016-12-23 04:57:55 +00:00
|
|
|
|
2017-10-17 19:42:56 +00:00
|
|
|
if (DO_BIC(BIC_USEC))
|
|
|
|
outp += sprintf(outp, "%susec", (printed++ ? delim : ""));
|
|
|
|
if (DO_BIC(BIC_TOD))
|
|
|
|
outp += sprintf(outp, "%sTime_Of_Day_Seconds", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Package))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPackage", (printed++ ? delim : ""));
|
2019-02-15 03:17:40 +00:00
|
|
|
if (DO_BIC(BIC_Die))
|
|
|
|
outp += sprintf(outp, "%sDie", (printed++ ? delim : ""));
|
2018-06-01 14:04:35 +00:00
|
|
|
if (DO_BIC(BIC_Node))
|
|
|
|
outp += sprintf(outp, "%sNode", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Core))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCore", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCPU", (printed++ ? delim : ""));
|
2018-06-06 21:44:48 +00:00
|
|
|
if (DO_BIC(BIC_APIC))
|
|
|
|
outp += sprintf(outp, "%sAPIC", (printed++ ? delim : ""));
|
|
|
|
if (DO_BIC(BIC_X2APIC))
|
|
|
|
outp += sprintf(outp, "%sX2APIC", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Avg_MHz))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sAvg_MHz", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Busy))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sBusy%%", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Bzy_MHz))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sBzy_MHz", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_TSC_MHz))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sTSC_MHz", (printed++ ? delim : ""));
|
2015-02-23 05:34:57 +00:00
|
|
|
|
2017-02-16 02:45:40 +00:00
|
|
|
if (DO_BIC(BIC_IRQ)) {
|
|
|
|
if (sums_need_wide_columns)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s IRQ", (printed++ ? delim : ""));
|
2017-02-16 02:45:40 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sIRQ", (printed++ ? delim : ""));
|
2017-02-16 02:45:40 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_SMI))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sSMI", (printed++ ? delim : ""));
|
2015-02-23 05:34:57 +00:00
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (mp = sys.tp; mp; mp = mp->next) {
|
2017-02-22 04:21:13 +00:00
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
if (mp->format == FORMAT_RAW) {
|
|
|
|
if (mp->width == 64)
|
2017-02-22 04:21:13 +00:00
|
|
|
outp += sprintf(outp, "%s%18.18s", (printed++ ? delim : ""), mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
else
|
2017-02-22 04:21:13 +00:00
|
|
|
outp += sprintf(outp, "%s%10.10s", (printed++ ? delim : ""), mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else {
|
2017-02-16 02:45:40 +00:00
|
|
|
if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
|
2017-02-22 04:21:13 +00:00
|
|
|
outp += sprintf(outp, "%s%8s", (printed++ ? delim : ""), mp->name);
|
2017-02-16 02:45:40 +00:00
|
|
|
else
|
2017-02-22 04:21:13 +00:00
|
|
|
outp += sprintf(outp, "%s%s", (printed++ ? delim : ""), mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c1))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCPU%%c1", (printed++ ? delim : ""));
|
2019-03-19 21:52:32 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c3))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCPU%%c3", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c6))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCPU%%c6", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c7))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCPU%%c7", (printed++ ? delim : ""));
|
2017-02-10 03:22:13 +00:00
|
|
|
|
2017-02-10 05:27:20 +00:00
|
|
|
if (DO_BIC(BIC_Mod_c6))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sMod%%c6", (printed++ ? delim : ""));
|
2017-02-10 03:22:13 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CoreTmp))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCoreTmp", (printed++ ? delim : ""));
|
2016-12-23 04:57:55 +00:00
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
if (do_rapl && !rapl_joules) {
|
|
|
|
if (DO_BIC(BIC_CorWatt) && (do_rapl & RAPL_PER_CORE_ENERGY))
|
|
|
|
outp += sprintf(outp, "%sCorWatt", (printed++ ? delim : ""));
|
|
|
|
} else if (do_rapl && rapl_joules) {
|
|
|
|
if (DO_BIC(BIC_Cor_J) && (do_rapl & RAPL_PER_CORE_ENERGY))
|
|
|
|
outp += sprintf(outp, "%sCor_J", (printed++ ? delim : ""));
|
|
|
|
}
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (mp = sys.cp; mp; mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW) {
|
|
|
|
if (mp->width == 64)
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
outp += sprintf(outp, "%s%18.18s", delim, mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
else
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
outp += sprintf(outp, "%s%10.10s", delim, mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else {
|
2017-02-16 02:45:40 +00:00
|
|
|
if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
|
|
|
|
outp += sprintf(outp, "%s%8s", delim, mp->name);
|
|
|
|
else
|
|
|
|
outp += sprintf(outp, "%s%s", delim, mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_PkgTmp))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkgTmp", (printed++ ? delim : ""));
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFX_rc6))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sGFX%%rc6", (printed++ ? delim : ""));
|
2016-02-27 06:28:12 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFXMHz))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sGFXMHz", (printed++ ? delim : ""));
|
2016-02-27 05:37:54 +00:00
|
|
|
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Totl_c0))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sTotl%%C0", (printed++ ? delim : ""));
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Any_c0))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sAny%%C0", (printed++ ? delim : ""));
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_GFX_c0))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sGFX%%C0", (printed++ ? delim : ""));
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_CPUGFX))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCPUGFX%%", (printed++ ? delim : ""));
|
2015-03-26 04:50:30 +00:00
|
|
|
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc2))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkg%%pc2", (printed++ ? delim : ""));
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc3))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkg%%pc3", (printed++ ? delim : ""));
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc6))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkg%%pc6", (printed++ ? delim : ""));
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc7))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkg%%pc7", (printed++ ? delim : ""));
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc8))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkg%%pc8", (printed++ ? delim : ""));
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc9))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkg%%pc9", (printed++ ? delim : ""));
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc10))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPk%%pc10", (printed++ ? delim : ""));
|
2018-06-01 16:35:53 +00:00
|
|
|
if (DO_BIC(BIC_CPU_LPI))
|
|
|
|
outp += sprintf(outp, "%sCPU%%LPI", (printed++ ? delim : ""));
|
|
|
|
if (DO_BIC(BIC_SYS_LPI))
|
|
|
|
outp += sprintf(outp, "%sSYS%%LPI", (printed++ ? delim : ""));
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl && !rapl_joules) {
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_PkgWatt))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkgWatt", (printed++ ? delim : ""));
|
2018-08-17 16:34:41 +00:00
|
|
|
if (DO_BIC(BIC_CorWatt) && !(do_rapl & RAPL_PER_CORE_ENERGY))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCorWatt", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFXWatt))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sGFXWatt", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_RAMWatt))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sRAMWatt", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_PKG__))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPKG_%%", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_RAM__))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sRAM_%%", (printed++ ? delim : ""));
|
2015-01-23 05:12:33 +00:00
|
|
|
} else if (do_rapl && rapl_joules) {
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Pkg_J))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPkg_J", (printed++ ? delim : ""));
|
2018-08-17 16:34:41 +00:00
|
|
|
if (DO_BIC(BIC_Cor_J) && !(do_rapl & RAPL_PER_CORE_ENERGY))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sCor_J", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFX_J))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sGFX_J", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_RAM_J))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sRAM_J", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_PKG__))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sPKG_%%", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_RAM__))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%sRAM_%%", (printed++ ? delim : ""));
|
2013-12-16 18:23:41 +00:00
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
for (mp = sys.pp; mp; mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW) {
|
|
|
|
if (mp->width == 64)
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
outp += sprintf(outp, "%s%18.18s", delim, mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
else
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
outp += sprintf(outp, "%s%10.10s", delim, mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else {
|
2017-02-16 02:45:40 +00:00
|
|
|
if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
|
|
|
|
outp += sprintf(outp, "%s%8s", delim, mp->name);
|
|
|
|
else
|
|
|
|
outp += sprintf(outp, "%s%s", delim, mp->name);
|
2016-12-23 04:57:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
outp += sprintf(outp, "\n");
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
int dump_counters(struct thread_data *t, struct core_data *c,
|
|
|
|
struct pkg_data *p)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2016-12-23 04:57:55 +00:00
|
|
|
int i;
|
|
|
|
struct msr_counter *mp;
|
|
|
|
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "t %p, c %p, p %p\n", t, c, p);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
if (t) {
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "CPU: %d flags 0x%x\n",
|
|
|
|
t->cpu_id, t->flags);
|
|
|
|
outp += sprintf(outp, "TSC: %016llX\n", t->tsc);
|
|
|
|
outp += sprintf(outp, "aperf: %016llX\n", t->aperf);
|
|
|
|
outp += sprintf(outp, "mperf: %016llX\n", t->mperf);
|
|
|
|
outp += sprintf(outp, "c1: %016llX\n", t->c1);
|
tools/power turbostat: remove obsolete -M, -m, -C, -c options
The new --add option has replaced the -M, -m, -C, -c options
Eg.
-M 0x10 is now --add msr0x10,raw
-m 0x10 is now --add msr0x10,raw,u32
-C 0x10 is now --add msr0x10,delta
-c 0x10 is now --add msr0x10,delta,u32
The --add option can be repeated to add any number of counters,
while the previous options were limited to adding one of each type.
In addition, the --add option can accept a column label,
and can also display a counter as a percentage of elapsed cycles.
Eg. --add msr0x3fe,core,percent,MY_CC3
Signed-off-by: Len Brown <len.brown@intel.com>
2016-12-24 20:18:37 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_IRQ))
|
2017-02-16 02:45:40 +00:00
|
|
|
outp += sprintf(outp, "IRQ: %lld\n", t->irq_count);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_SMI))
|
2017-02-15 03:07:52 +00:00
|
|
|
outp += sprintf(outp, "SMI: %d\n", t->smi_count);
|
2016-12-23 04:57:55 +00:00
|
|
|
|
|
|
|
for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
|
|
|
|
outp += sprintf(outp, "tADDED [%d] msr0x%x: %08llX\n",
|
|
|
|
i, mp->msr_num, t->counter[i]);
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (c) {
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "core: %d\n", c->core_id);
|
|
|
|
outp += sprintf(outp, "c3: %016llX\n", c->c3);
|
|
|
|
outp += sprintf(outp, "c6: %016llX\n", c->c6);
|
|
|
|
outp += sprintf(outp, "c7: %016llX\n", c->c7);
|
|
|
|
outp += sprintf(outp, "DTS: %dC\n", c->core_temp_c);
|
2018-08-17 16:34:41 +00:00
|
|
|
outp += sprintf(outp, "Joules: %0X\n", c->core_energy);
|
2016-12-23 04:57:55 +00:00
|
|
|
|
|
|
|
for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
|
|
|
|
outp += sprintf(outp, "cADDED [%d] msr0x%x: %08llX\n",
|
|
|
|
i, mp->msr_num, c->counter[i]);
|
|
|
|
}
|
2017-02-10 05:27:20 +00:00
|
|
|
outp += sprintf(outp, "mc6_us: %016llX\n", c->mc6_us);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (p) {
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "package: %d\n", p->package_id);
|
2015-03-26 04:50:30 +00:00
|
|
|
|
|
|
|
outp += sprintf(outp, "Weighted cores: %016llX\n", p->pkg_wtd_core_c0);
|
|
|
|
outp += sprintf(outp, "Any cores: %016llX\n", p->pkg_any_core_c0);
|
|
|
|
outp += sprintf(outp, "Any GFX: %016llX\n", p->pkg_any_gfxe_c0);
|
|
|
|
outp += sprintf(outp, "CPU + GFX: %016llX\n", p->pkg_both_core_gfxe_c0);
|
|
|
|
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc3))
|
2015-02-10 04:39:45 +00:00
|
|
|
outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc6))
|
2015-02-10 04:39:45 +00:00
|
|
|
outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc7))
|
2015-02-10 04:39:45 +00:00
|
|
|
outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "pc8: %016llX\n", p->pc8);
|
|
|
|
outp += sprintf(outp, "pc9: %016llX\n", p->pc9);
|
|
|
|
outp += sprintf(outp, "pc10: %016llX\n", p->pc10);
|
2018-06-01 16:35:53 +00:00
|
|
|
outp += sprintf(outp, "cpu_lpi: %016llX\n", p->cpu_lpi);
|
|
|
|
outp += sprintf(outp, "sys_lpi: %016llX\n", p->sys_lpi);
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "Joules PKG: %0X\n", p->energy_pkg);
|
|
|
|
outp += sprintf(outp, "Joules COR: %0X\n", p->energy_cores);
|
|
|
|
outp += sprintf(outp, "Joules GFX: %0X\n", p->energy_gfx);
|
|
|
|
outp += sprintf(outp, "Joules RAM: %0X\n", p->energy_dram);
|
|
|
|
outp += sprintf(outp, "Throttle PKG: %0X\n",
|
|
|
|
p->rapl_pkg_perf_status);
|
|
|
|
outp += sprintf(outp, "Throttle RAM: %0X\n",
|
|
|
|
p->rapl_dram_perf_status);
|
|
|
|
outp += sprintf(outp, "PTM: %dC\n", p->pkg_temp_c);
|
2016-12-23 04:57:55 +00:00
|
|
|
|
|
|
|
for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
|
|
|
|
outp += sprintf(outp, "pADDED [%d] msr0x%x: %08llX\n",
|
|
|
|
i, mp->msr_num, p->counter[i]);
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2014-01-23 15:13:15 +00:00
|
|
|
|
|
|
|
outp += sprintf(outp, "\n");
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2012-02-06 23:37:16 +00:00
|
|
|
/*
|
|
|
|
* column formatting convention & formats
|
|
|
|
*/
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
int format_counters(struct thread_data *t, struct core_data *c,
|
|
|
|
struct pkg_data *p)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2017-02-10 05:29:51 +00:00
|
|
|
double interval_float, tsc;
|
2014-02-06 05:55:19 +00:00
|
|
|
char *fmt8;
|
2016-12-23 04:57:55 +00:00
|
|
|
int i;
|
|
|
|
struct msr_counter *mp;
|
2017-02-17 04:07:51 +00:00
|
|
|
char *delim = "\t";
|
|
|
|
int printed = 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* if showing only 1st thread in core and this isn't one, bail out */
|
|
|
|
if (show_core_only && !(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* if showing only 1st thread in pkg and this isn't one, bail out */
|
|
|
|
if (show_pkg_only && !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
|
|
|
return 0;
|
|
|
|
|
2017-02-11 04:54:15 +00:00
|
|
|
/*if not summary line and --cpu is used */
|
|
|
|
if ((t != &average.threads) &&
|
|
|
|
(cpu_subset && !CPU_ISSET_S(t->cpu_id, cpu_subset_size, cpu_subset)))
|
|
|
|
return 0;
|
|
|
|
|
2017-10-17 19:42:56 +00:00
|
|
|
if (DO_BIC(BIC_USEC)) {
|
2017-05-28 04:06:55 +00:00
|
|
|
/* on each row, print how many usec each timestamp took to gather */
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
timersub(&t->tv_end, &t->tv_begin, &tv);
|
|
|
|
outp += sprintf(outp, "%5ld\t", tv.tv_sec * 1000000 + tv.tv_usec);
|
|
|
|
}
|
|
|
|
|
2017-10-17 19:42:56 +00:00
|
|
|
/* Time_Of_Day_Seconds: on each row, print sec.usec last timestamp taken */
|
|
|
|
if (DO_BIC(BIC_TOD))
|
|
|
|
outp += sprintf(outp, "%10ld.%06ld\t", t->tv_end.tv_sec, t->tv_end.tv_usec);
|
|
|
|
|
2019-03-25 17:32:42 +00:00
|
|
|
interval_float = t->tv_delta.tv_sec + t->tv_delta.tv_usec/1000000.0;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2017-02-10 05:29:51 +00:00
|
|
|
tsc = t->tsc * tsc_tweak;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* topo columns, print blanks on 1st (average) line */
|
|
|
|
if (t == &average.threads) {
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Package))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
2019-02-15 03:17:40 +00:00
|
|
|
if (DO_BIC(BIC_Die))
|
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
2018-06-01 14:04:35 +00:00
|
|
|
if (DO_BIC(BIC_Node))
|
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Core))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
2018-06-06 21:44:48 +00:00
|
|
|
if (DO_BIC(BIC_APIC))
|
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
|
|
|
if (DO_BIC(BIC_X2APIC))
|
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
2010-10-23 03:53:03 +00:00
|
|
|
} else {
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Package)) {
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (p)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->package_id);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2019-02-15 03:17:40 +00:00
|
|
|
if (DO_BIC(BIC_Die)) {
|
|
|
|
if (c)
|
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), cpus[t->cpu_id].die_id);
|
|
|
|
else
|
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
|
|
|
}
|
2018-06-01 14:04:35 +00:00
|
|
|
if (DO_BIC(BIC_Node)) {
|
|
|
|
if (t)
|
|
|
|
outp += sprintf(outp, "%s%d",
|
|
|
|
(printed++ ? delim : ""),
|
|
|
|
cpus[t->cpu_id].physical_node_id);
|
|
|
|
else
|
|
|
|
outp += sprintf(outp, "%s-",
|
|
|
|
(printed++ ? delim : ""));
|
|
|
|
}
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Core)) {
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (c)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), c->core_id);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s-", (printed++ ? delim : ""));
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), t->cpu_id);
|
2018-06-06 21:44:48 +00:00
|
|
|
if (DO_BIC(BIC_APIC))
|
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), t->apic_id);
|
|
|
|
if (DO_BIC(BIC_X2APIC))
|
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), t->x2apic_id);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
2014-02-06 05:55:19 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Avg_MHz))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.0f", (printed++ ? delim : ""),
|
2014-02-06 05:55:19 +00:00
|
|
|
1.0 / units * t->aperf / interval_float);
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Busy))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * t->mperf/tsc);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Bzy_MHz)) {
|
2015-10-20 02:37:40 +00:00
|
|
|
if (has_base_hz)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.0f", (printed++ ? delim : ""), base_hz / units * t->aperf / t->mperf);
|
2015-10-20 02:37:40 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.0f", (printed++ ? delim : ""),
|
2017-02-10 05:29:51 +00:00
|
|
|
tsc / units * t->aperf / t->mperf / interval_float);
|
2015-10-20 02:37:40 +00:00
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_TSC_MHz))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.0f", (printed++ ? delim : ""), 1.0 * t->tsc/units/interval_float);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2016-02-27 04:48:05 +00:00
|
|
|
/* IRQ */
|
2017-02-16 02:45:40 +00:00
|
|
|
if (DO_BIC(BIC_IRQ)) {
|
|
|
|
if (sums_need_wide_columns)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), t->irq_count);
|
2017-02-16 02:45:40 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), t->irq_count);
|
2017-02-16 02:45:40 +00:00
|
|
|
}
|
2016-02-27 04:48:05 +00:00
|
|
|
|
2015-02-23 05:34:57 +00:00
|
|
|
/* SMI */
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_SMI))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), t->smi_count);
|
2015-02-23 05:34:57 +00:00
|
|
|
|
2017-02-10 03:22:13 +00:00
|
|
|
/* Added counters */
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW) {
|
|
|
|
if (mp->width == 32)
|
2017-02-23 23:10:27 +00:00
|
|
|
outp += sprintf(outp, "%s0x%08x", (printed++ ? delim : ""), (unsigned int) t->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), t->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else if (mp->format == FORMAT_DELTA) {
|
2017-02-16 02:45:40 +00:00
|
|
|
if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), t->counter[i]);
|
2017-02-16 02:45:40 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), t->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else if (mp->format == FORMAT_PERCENT) {
|
2017-02-09 23:25:22 +00:00
|
|
|
if (mp->type == COUNTER_USEC)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), t->counter[i]/interval_float/10000);
|
2017-02-09 23:25:22 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * t->counter[i]/tsc);
|
2016-12-23 04:57:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
/* C1 */
|
|
|
|
if (DO_BIC(BIC_CPU_c1))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * t->c1/tsc);
|
2017-02-09 23:25:22 +00:00
|
|
|
|
|
|
|
|
2017-02-10 03:22:13 +00:00
|
|
|
/* print per-core data only for 1st thread in core */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
|
|
|
|
goto done;
|
|
|
|
|
2019-03-19 21:52:32 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c3))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->c3/tsc);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c6))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->c6/tsc);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c7))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->c7/tsc);
|
2017-02-10 03:22:13 +00:00
|
|
|
|
2017-02-10 05:27:20 +00:00
|
|
|
/* Mod%c6 */
|
|
|
|
if (DO_BIC(BIC_Mod_c6))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->mc6_us / tsc);
|
2017-02-10 05:27:20 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CoreTmp))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), c->core_temp_c);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW) {
|
|
|
|
if (mp->width == 32)
|
2017-02-23 23:10:27 +00:00
|
|
|
outp += sprintf(outp, "%s0x%08x", (printed++ ? delim : ""), (unsigned int) c->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), c->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else if (mp->format == FORMAT_DELTA) {
|
2017-02-16 02:45:40 +00:00
|
|
|
if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), c->counter[i]);
|
2017-02-16 02:45:40 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), c->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else if (mp->format == FORMAT_PERCENT) {
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * c->counter[i]/tsc);
|
2016-12-23 04:57:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
/*
|
|
|
|
* If measurement interval exceeds minimum RAPL Joule Counter range,
|
|
|
|
* indicate that results are suspect by printing "**" in fraction place.
|
|
|
|
*/
|
|
|
|
if (interval_float < rapl_joule_counter_range)
|
|
|
|
fmt8 = "%s%.2f";
|
|
|
|
else
|
|
|
|
fmt8 = "%6.0f**";
|
|
|
|
|
|
|
|
if (DO_BIC(BIC_CorWatt) && (do_rapl & RAPL_PER_CORE_ENERGY))
|
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), c->core_energy * rapl_energy_units / interval_float);
|
|
|
|
if (DO_BIC(BIC_Cor_J) && (do_rapl & RAPL_PER_CORE_ENERGY))
|
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), c->core_energy * rapl_energy_units);
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* print per-package data only for 1st core in package */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
|
|
|
goto done;
|
|
|
|
|
2015-03-26 04:50:30 +00:00
|
|
|
/* PkgTmp */
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_PkgTmp))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->pkg_temp_c);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2016-02-27 06:28:12 +00:00
|
|
|
/* GFXrc6 */
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFX_rc6)) {
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
if (p->gfx_rc6_ms == -1) { /* detect GFX counter reset */
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s**.**", (printed++ ? delim : ""));
|
2016-04-06 21:16:00 +00:00
|
|
|
} else {
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""),
|
2016-04-06 21:16:00 +00:00
|
|
|
p->gfx_rc6_ms / 10.0 / interval_float);
|
|
|
|
}
|
|
|
|
}
|
2016-02-27 06:28:12 +00:00
|
|
|
|
2016-02-27 05:37:54 +00:00
|
|
|
/* GFXMHz */
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFXMHz))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%d", (printed++ ? delim : ""), p->gfx_mhz);
|
2016-02-27 05:37:54 +00:00
|
|
|
|
2015-03-26 04:50:30 +00:00
|
|
|
/* Totl%C0, Any%C0 GFX%C0 CPUGFX% */
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Totl_c0))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pkg_wtd_core_c0/tsc);
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Any_c0))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pkg_any_core_c0/tsc);
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_GFX_c0))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pkg_any_gfxe_c0/tsc);
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_CPUGFX))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pkg_both_core_gfxe_c0/tsc);
|
2015-03-26 04:50:30 +00:00
|
|
|
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc2))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc2/tsc);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc3))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc3/tsc);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc6))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc6/tsc);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc7))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc7/tsc);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc8))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc8/tsc);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc9))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc9/tsc);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc10))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->pc10/tsc);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2018-06-01 16:35:53 +00:00
|
|
|
if (DO_BIC(BIC_CPU_LPI))
|
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->cpu_lpi / 1000000.0 / interval_float);
|
|
|
|
if (DO_BIC(BIC_SYS_LPI))
|
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->sys_lpi / 1000000.0 / interval_float);
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_PkgWatt))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_pkg * rapl_energy_units / interval_float);
|
2018-08-17 16:34:41 +00:00
|
|
|
if (DO_BIC(BIC_CorWatt) && !(do_rapl & RAPL_PER_CORE_ENERGY))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_cores * rapl_energy_units / interval_float);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFXWatt))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_gfx * rapl_energy_units / interval_float);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_RAMWatt))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_dram * rapl_dram_energy_units / interval_float);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Pkg_J))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_pkg * rapl_energy_units);
|
2018-08-17 16:34:41 +00:00
|
|
|
if (DO_BIC(BIC_Cor_J) && !(do_rapl & RAPL_PER_CORE_ENERGY))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_cores * rapl_energy_units);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFX_J))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_gfx * rapl_energy_units);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_RAM_J))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), p->energy_dram * rapl_dram_energy_units);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_PKG__))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_RAM__))
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, fmt8, (printed++ ? delim : ""), 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
|
2017-02-10 05:25:41 +00:00
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW) {
|
|
|
|
if (mp->width == 32)
|
2017-02-23 23:10:27 +00:00
|
|
|
outp += sprintf(outp, "%s0x%08x", (printed++ ? delim : ""), (unsigned int) p->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s0x%016llx", (printed++ ? delim : ""), p->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else if (mp->format == FORMAT_DELTA) {
|
2017-02-16 02:45:40 +00:00
|
|
|
if ((mp->type == COUNTER_ITEMS) && sums_need_wide_columns)
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%8lld", (printed++ ? delim : ""), p->counter[i]);
|
2017-02-16 02:45:40 +00:00
|
|
|
else
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%lld", (printed++ ? delim : ""), p->counter[i]);
|
2016-12-23 04:57:55 +00:00
|
|
|
} else if (mp->format == FORMAT_PERCENT) {
|
2017-02-17 04:07:51 +00:00
|
|
|
outp += sprintf(outp, "%s%.2f", (printed++ ? delim : ""), 100.0 * p->counter[i]/tsc);
|
2016-12-23 04:57:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
done:
|
2018-01-28 03:39:21 +00:00
|
|
|
if (*(outp - 1) != '\n')
|
|
|
|
outp += sprintf(outp, "\n");
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
return 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
void flush_output_stdout(void)
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
{
|
2016-02-14 04:36:17 +00:00
|
|
|
FILE *filep;
|
|
|
|
|
|
|
|
if (outf == stderr)
|
|
|
|
filep = stdout;
|
|
|
|
else
|
|
|
|
filep = outf;
|
|
|
|
|
|
|
|
fputs(output_buffer, filep);
|
|
|
|
fflush(filep);
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
outp = output_buffer;
|
|
|
|
}
|
2016-02-14 04:36:17 +00:00
|
|
|
void flush_output_stderr(void)
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
{
|
2016-02-14 04:36:17 +00:00
|
|
|
fputs(output_buffer, outf);
|
|
|
|
fflush(outf);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
outp = output_buffer;
|
|
|
|
}
|
|
|
|
void format_all_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2012-02-06 23:37:16 +00:00
|
|
|
static int printed;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2012-02-06 23:37:16 +00:00
|
|
|
if (!printed || !summary_only)
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
print_header("\t");
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2018-07-20 18:47:03 +00:00
|
|
|
format_counters(&average.threads, &average.cores, &average.packages);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2012-02-06 23:37:16 +00:00
|
|
|
printed = 1;
|
|
|
|
|
|
|
|
if (summary_only)
|
|
|
|
return;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
for_all_cpus(format_counters, t, c, p);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
#define DELTA_WRAP32(new, old) \
|
|
|
|
if (new > old) { \
|
|
|
|
old = new - old; \
|
|
|
|
} else { \
|
|
|
|
old = 0x100000000 + new - old; \
|
|
|
|
}
|
|
|
|
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
int
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
delta_package(struct pkg_data *new, struct pkg_data *old)
|
|
|
|
{
|
2016-12-23 04:57:55 +00:00
|
|
|
int i;
|
|
|
|
struct msr_counter *mp;
|
2015-03-26 04:50:30 +00:00
|
|
|
|
2017-05-21 00:11:55 +00:00
|
|
|
|
|
|
|
if (DO_BIC(BIC_Totl_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
old->pkg_wtd_core_c0 = new->pkg_wtd_core_c0 - old->pkg_wtd_core_c0;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Any_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
old->pkg_any_core_c0 = new->pkg_any_core_c0 - old->pkg_any_core_c0;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_GFX_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
old->pkg_any_gfxe_c0 = new->pkg_any_gfxe_c0 - old->pkg_any_gfxe_c0;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_CPUGFX))
|
2015-03-26 04:50:30 +00:00
|
|
|
old->pkg_both_core_gfxe_c0 = new->pkg_both_core_gfxe_c0 - old->pkg_both_core_gfxe_c0;
|
2017-05-21 00:11:55 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
old->pc2 = new->pc2 - old->pc2;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc3))
|
2015-02-10 04:39:45 +00:00
|
|
|
old->pc3 = new->pc3 - old->pc3;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc6))
|
2015-02-10 04:39:45 +00:00
|
|
|
old->pc6 = new->pc6 - old->pc6;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc7))
|
2015-02-10 04:39:45 +00:00
|
|
|
old->pc7 = new->pc7 - old->pc7;
|
2012-11-21 13:22:43 +00:00
|
|
|
old->pc8 = new->pc8 - old->pc8;
|
|
|
|
old->pc9 = new->pc9 - old->pc9;
|
|
|
|
old->pc10 = new->pc10 - old->pc10;
|
2018-06-01 16:35:53 +00:00
|
|
|
old->cpu_lpi = new->cpu_lpi - old->cpu_lpi;
|
|
|
|
old->sys_lpi = new->sys_lpi - old->sys_lpi;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
old->pkg_temp_c = new->pkg_temp_c;
|
|
|
|
|
2016-04-06 21:16:00 +00:00
|
|
|
/* flag an error when rc6 counter resets/wraps */
|
|
|
|
if (old->gfx_rc6_ms > new->gfx_rc6_ms)
|
|
|
|
old->gfx_rc6_ms = -1;
|
|
|
|
else
|
|
|
|
old->gfx_rc6_ms = new->gfx_rc6_ms - old->gfx_rc6_ms;
|
|
|
|
|
2016-02-27 05:37:54 +00:00
|
|
|
old->gfx_mhz = new->gfx_mhz;
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
DELTA_WRAP32(new->energy_pkg, old->energy_pkg);
|
|
|
|
DELTA_WRAP32(new->energy_cores, old->energy_cores);
|
|
|
|
DELTA_WRAP32(new->energy_gfx, old->energy_gfx);
|
|
|
|
DELTA_WRAP32(new->energy_dram, old->energy_dram);
|
|
|
|
DELTA_WRAP32(new->rapl_pkg_perf_status, old->rapl_pkg_perf_status);
|
|
|
|
DELTA_WRAP32(new->rapl_dram_perf_status, old->rapl_dram_perf_status);
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
old->counter[i] = new->counter[i];
|
|
|
|
else
|
|
|
|
old->counter[i] = new->counter[i] - old->counter[i];
|
|
|
|
}
|
|
|
|
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
return 0;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
void
|
|
|
|
delta_core(struct core_data *new, struct core_data *old)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2016-12-23 04:57:55 +00:00
|
|
|
int i;
|
|
|
|
struct msr_counter *mp;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
old->c3 = new->c3 - old->c3;
|
|
|
|
old->c6 = new->c6 - old->c6;
|
|
|
|
old->c7 = new->c7 - old->c7;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
old->core_temp_c = new->core_temp_c;
|
2017-02-10 05:27:20 +00:00
|
|
|
old->mc6_us = new->mc6_us - old->mc6_us;
|
2016-12-23 04:57:55 +00:00
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
DELTA_WRAP32(new->core_energy, old->core_energy);
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
old->counter[i] = new->counter[i];
|
|
|
|
else
|
|
|
|
old->counter[i] = new->counter[i] - old->counter[i];
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2012-06-14 01:31:46 +00:00
|
|
|
/*
|
|
|
|
* old = new - old
|
|
|
|
*/
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
int
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
delta_thread(struct thread_data *new, struct thread_data *old,
|
|
|
|
struct core_data *core_delta)
|
|
|
|
{
|
2016-12-23 04:57:55 +00:00
|
|
|
int i;
|
|
|
|
struct msr_counter *mp;
|
|
|
|
|
2018-06-06 21:44:48 +00:00
|
|
|
/* we run cpuid just the 1st time, copy the results */
|
|
|
|
if (DO_BIC(BIC_APIC))
|
|
|
|
new->apic_id = old->apic_id;
|
|
|
|
if (DO_BIC(BIC_X2APIC))
|
|
|
|
new->x2apic_id = old->x2apic_id;
|
|
|
|
|
2017-10-17 19:42:56 +00:00
|
|
|
/*
|
|
|
|
* the timestamps from start of measurement interval are in "old"
|
|
|
|
* the timestamp from end of measurement interval are in "new"
|
|
|
|
* over-write old w/ new so we can print end of interval values
|
|
|
|
*/
|
|
|
|
|
2019-03-25 17:32:42 +00:00
|
|
|
timersub(&new->tv_begin, &old->tv_begin, &old->tv_delta);
|
2017-10-17 19:42:56 +00:00
|
|
|
old->tv_begin = new->tv_begin;
|
|
|
|
old->tv_end = new->tv_end;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
old->tsc = new->tsc - old->tsc;
|
|
|
|
|
|
|
|
/* check for TSC < 1 Mcycles over interval */
|
2013-08-21 00:20:18 +00:00
|
|
|
if (old->tsc < (1000 * 1000))
|
|
|
|
errx(-3, "Insanely slow TSC rate, TSC stops in idle?\n"
|
|
|
|
"You can disable all c-states by booting with \"idle=poll\"\n"
|
|
|
|
"or just the deep ones with \"processor.max_cstate=1\"");
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
old->c1 = new->c1 - old->c1;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Avg_MHz) || DO_BIC(BIC_Busy) || DO_BIC(BIC_Bzy_MHz)) {
|
2015-01-23 06:33:58 +00:00
|
|
|
if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
|
|
|
|
old->aperf = new->aperf - old->aperf;
|
|
|
|
old->mperf = new->mperf - old->mperf;
|
|
|
|
} else {
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
return -1;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
if (use_c1_residency_msr) {
|
|
|
|
/*
|
|
|
|
* Some models have a dedicated C1 residency MSR,
|
|
|
|
* which should be more accurate than the derivation below.
|
|
|
|
*/
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* As counter collection is not atomic,
|
|
|
|
* it is possible for mperf's non-halted cycles + idle states
|
|
|
|
* to exceed TSC's all cycles: show c1 = 0% in that case.
|
|
|
|
*/
|
2017-04-12 23:44:51 +00:00
|
|
|
if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > (old->tsc * tsc_tweak))
|
2013-11-09 05:30:16 +00:00
|
|
|
old->c1 = 0;
|
|
|
|
else {
|
|
|
|
/* normal case, derive c1 */
|
2017-02-10 05:29:51 +00:00
|
|
|
old->c1 = (old->tsc * tsc_tweak) - old->mperf - core_delta->c3
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
- core_delta->c6 - core_delta->c7;
|
2013-11-09 05:30:16 +00:00
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2012-06-14 01:31:46 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (old->mperf == 0) {
|
2016-02-14 04:36:17 +00:00
|
|
|
if (debug > 1)
|
|
|
|
fprintf(outf, "cpu%d MPERF 0!\n", old->cpu_id);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
old->mperf = 1; /* divide by 0 protection */
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_IRQ))
|
2016-02-27 04:48:05 +00:00
|
|
|
old->irq_count = new->irq_count - old->irq_count;
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_SMI))
|
2013-02-10 22:19:24 +00:00
|
|
|
old->smi_count = new->smi_count - old->smi_count;
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
old->counter[i] = new->counter[i];
|
|
|
|
else
|
|
|
|
old->counter[i] = new->counter[i] - old->counter[i];
|
|
|
|
}
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
return 0;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int delta_cpu(struct thread_data *t, struct core_data *c,
|
|
|
|
struct pkg_data *p, struct thread_data *t2,
|
|
|
|
struct core_data *c2, struct pkg_data *p2)
|
|
|
|
{
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
int retval = 0;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* calculate core delta only for 1st thread in core */
|
|
|
|
if (t->flags & CPU_IS_FIRST_THREAD_IN_CORE)
|
|
|
|
delta_core(c, c2);
|
|
|
|
|
|
|
|
/* always calculate thread delta */
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
retval = delta_thread(t, t2, c2); /* c2 is core delta */
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
/* calculate package delta only for 1st core in package */
|
|
|
|
if (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
retval = delta_package(p, p2);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
return retval;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
{
|
2016-12-23 04:57:55 +00:00
|
|
|
int i;
|
|
|
|
struct msr_counter *mp;
|
|
|
|
|
2017-10-17 19:42:56 +00:00
|
|
|
t->tv_begin.tv_sec = 0;
|
|
|
|
t->tv_begin.tv_usec = 0;
|
|
|
|
t->tv_end.tv_sec = 0;
|
|
|
|
t->tv_end.tv_usec = 0;
|
2019-03-25 17:32:42 +00:00
|
|
|
t->tv_delta.tv_sec = 0;
|
|
|
|
t->tv_delta.tv_usec = 0;
|
2017-10-17 19:42:56 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
t->tsc = 0;
|
|
|
|
t->aperf = 0;
|
|
|
|
t->mperf = 0;
|
|
|
|
t->c1 = 0;
|
|
|
|
|
2016-02-27 04:48:05 +00:00
|
|
|
t->irq_count = 0;
|
|
|
|
t->smi_count = 0;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* tells format_counters to dump all fields from this set */
|
|
|
|
t->flags = CPU_IS_FIRST_THREAD_IN_CORE | CPU_IS_FIRST_CORE_IN_PACKAGE;
|
|
|
|
|
|
|
|
c->c3 = 0;
|
|
|
|
c->c6 = 0;
|
|
|
|
c->c7 = 0;
|
2017-02-10 05:27:20 +00:00
|
|
|
c->mc6_us = 0;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
c->core_temp_c = 0;
|
2018-08-17 16:34:41 +00:00
|
|
|
c->core_energy = 0;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2015-03-26 04:50:30 +00:00
|
|
|
p->pkg_wtd_core_c0 = 0;
|
|
|
|
p->pkg_any_core_c0 = 0;
|
|
|
|
p->pkg_any_gfxe_c0 = 0;
|
|
|
|
p->pkg_both_core_gfxe_c0 = 0;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
p->pc2 = 0;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc3))
|
2015-02-10 04:39:45 +00:00
|
|
|
p->pc3 = 0;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc6))
|
2015-02-10 04:39:45 +00:00
|
|
|
p->pc6 = 0;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc7))
|
2015-02-10 04:39:45 +00:00
|
|
|
p->pc7 = 0;
|
2012-11-21 13:22:43 +00:00
|
|
|
p->pc8 = 0;
|
|
|
|
p->pc9 = 0;
|
|
|
|
p->pc10 = 0;
|
2018-06-01 16:35:53 +00:00
|
|
|
p->cpu_lpi = 0;
|
|
|
|
p->sys_lpi = 0;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
|
|
|
p->energy_pkg = 0;
|
|
|
|
p->energy_dram = 0;
|
|
|
|
p->energy_cores = 0;
|
|
|
|
p->energy_gfx = 0;
|
|
|
|
p->rapl_pkg_perf_status = 0;
|
|
|
|
p->rapl_dram_perf_status = 0;
|
|
|
|
p->pkg_temp_c = 0;
|
2016-02-27 05:37:54 +00:00
|
|
|
|
2016-02-27 06:28:12 +00:00
|
|
|
p->gfx_rc6_ms = 0;
|
2016-02-27 05:37:54 +00:00
|
|
|
p->gfx_mhz = 0;
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.tp; mp; i++, mp = mp->next)
|
|
|
|
t->counter[i] = 0;
|
|
|
|
|
|
|
|
for (i = 0, mp = sys.cp; mp; i++, mp = mp->next)
|
|
|
|
c->counter[i] = 0;
|
|
|
|
|
|
|
|
for (i = 0, mp = sys.pp; mp; i++, mp = mp->next)
|
|
|
|
p->counter[i] = 0;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
int sum_counters(struct thread_data *t, struct core_data *c,
|
|
|
|
struct pkg_data *p)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2016-12-23 04:57:55 +00:00
|
|
|
int i;
|
|
|
|
struct msr_counter *mp;
|
|
|
|
|
2018-06-06 21:44:48 +00:00
|
|
|
/* copy un-changing apic_id's */
|
|
|
|
if (DO_BIC(BIC_APIC))
|
|
|
|
average.threads.apic_id = t->apic_id;
|
|
|
|
if (DO_BIC(BIC_X2APIC))
|
|
|
|
average.threads.x2apic_id = t->x2apic_id;
|
|
|
|
|
2017-10-17 19:42:56 +00:00
|
|
|
/* remember first tv_begin */
|
|
|
|
if (average.threads.tv_begin.tv_sec == 0)
|
|
|
|
average.threads.tv_begin = t->tv_begin;
|
|
|
|
|
|
|
|
/* remember last tv_end */
|
|
|
|
average.threads.tv_end = t->tv_end;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
average.threads.tsc += t->tsc;
|
|
|
|
average.threads.aperf += t->aperf;
|
|
|
|
average.threads.mperf += t->mperf;
|
|
|
|
average.threads.c1 += t->c1;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2016-02-27 04:48:05 +00:00
|
|
|
average.threads.irq_count += t->irq_count;
|
|
|
|
average.threads.smi_count += t->smi_count;
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
continue;
|
|
|
|
average.threads.counter[i] += t->counter[i];
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* sum per-core values only for 1st thread in core */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
|
|
|
|
return 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
average.cores.c3 += c->c3;
|
|
|
|
average.cores.c6 += c->c6;
|
|
|
|
average.cores.c7 += c->c7;
|
2017-02-10 05:27:20 +00:00
|
|
|
average.cores.mc6_us += c->mc6_us;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
average.cores.core_temp_c = MAX(average.cores.core_temp_c, c->core_temp_c);
|
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
average.cores.core_energy += c->core_energy;
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
continue;
|
|
|
|
average.cores.counter[i] += c->counter[i];
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* sum per-pkg values only for 1st core in pkg */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
|
|
|
return 0;
|
|
|
|
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Totl_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
average.packages.pkg_wtd_core_c0 += p->pkg_wtd_core_c0;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Any_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
average.packages.pkg_any_core_c0 += p->pkg_any_core_c0;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_GFX_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
average.packages.pkg_any_gfxe_c0 += p->pkg_any_gfxe_c0;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_CPUGFX))
|
2015-03-26 04:50:30 +00:00
|
|
|
average.packages.pkg_both_core_gfxe_c0 += p->pkg_both_core_gfxe_c0;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
average.packages.pc2 += p->pc2;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc3))
|
2015-02-10 04:39:45 +00:00
|
|
|
average.packages.pc3 += p->pc3;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc6))
|
2015-02-10 04:39:45 +00:00
|
|
|
average.packages.pc6 += p->pc6;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc7))
|
2015-02-10 04:39:45 +00:00
|
|
|
average.packages.pc7 += p->pc7;
|
2012-11-21 13:22:43 +00:00
|
|
|
average.packages.pc8 += p->pc8;
|
|
|
|
average.packages.pc9 += p->pc9;
|
|
|
|
average.packages.pc10 += p->pc10;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2018-06-01 16:35:53 +00:00
|
|
|
average.packages.cpu_lpi = p->cpu_lpi;
|
|
|
|
average.packages.sys_lpi = p->sys_lpi;
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
average.packages.energy_pkg += p->energy_pkg;
|
|
|
|
average.packages.energy_dram += p->energy_dram;
|
|
|
|
average.packages.energy_cores += p->energy_cores;
|
|
|
|
average.packages.energy_gfx += p->energy_gfx;
|
|
|
|
|
2016-02-27 06:28:12 +00:00
|
|
|
average.packages.gfx_rc6_ms = p->gfx_rc6_ms;
|
2016-02-27 05:37:54 +00:00
|
|
|
average.packages.gfx_mhz = p->gfx_mhz;
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
average.packages.pkg_temp_c = MAX(average.packages.pkg_temp_c, p->pkg_temp_c);
|
|
|
|
|
|
|
|
average.packages.rapl_pkg_perf_status += p->rapl_pkg_perf_status;
|
|
|
|
average.packages.rapl_dram_perf_status += p->rapl_dram_perf_status;
|
2016-12-23 04:57:55 +00:00
|
|
|
|
|
|
|
for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
continue;
|
|
|
|
average.packages.counter[i] += p->counter[i];
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* sum the counters for all cpus in the system
|
|
|
|
* compute the weighted average
|
|
|
|
*/
|
|
|
|
void compute_average(struct thread_data *t, struct core_data *c,
|
|
|
|
struct pkg_data *p)
|
|
|
|
{
|
2016-12-23 04:57:55 +00:00
|
|
|
int i;
|
|
|
|
struct msr_counter *mp;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
clear_counters(&average.threads, &average.cores, &average.packages);
|
|
|
|
|
|
|
|
for_all_cpus(sum_counters, t, c, p);
|
|
|
|
|
2019-03-25 17:32:42 +00:00
|
|
|
/* Use the global time delta for the average. */
|
|
|
|
average.threads.tv_delta = tv_delta;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
average.threads.tsc /= topo.num_cpus;
|
|
|
|
average.threads.aperf /= topo.num_cpus;
|
|
|
|
average.threads.mperf /= topo.num_cpus;
|
|
|
|
average.threads.c1 /= topo.num_cpus;
|
|
|
|
|
2017-02-16 02:45:40 +00:00
|
|
|
if (average.threads.irq_count > 9999999)
|
|
|
|
sums_need_wide_columns = 1;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
average.cores.c3 /= topo.num_cores;
|
|
|
|
average.cores.c6 /= topo.num_cores;
|
|
|
|
average.cores.c7 /= topo.num_cores;
|
2017-02-10 05:27:20 +00:00
|
|
|
average.cores.mc6_us /= topo.num_cores;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Totl_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
average.packages.pkg_wtd_core_c0 /= topo.num_packages;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Any_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
average.packages.pkg_any_core_c0 /= topo.num_packages;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_GFX_c0))
|
2015-03-26 04:50:30 +00:00
|
|
|
average.packages.pkg_any_gfxe_c0 /= topo.num_packages;
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_CPUGFX))
|
2015-03-26 04:50:30 +00:00
|
|
|
average.packages.pkg_both_core_gfxe_c0 /= topo.num_packages;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
average.packages.pc2 /= topo.num_packages;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc3))
|
2015-02-10 04:39:45 +00:00
|
|
|
average.packages.pc3 /= topo.num_packages;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc6))
|
2015-02-10 04:39:45 +00:00
|
|
|
average.packages.pc6 /= topo.num_packages;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc7))
|
2015-02-10 04:39:45 +00:00
|
|
|
average.packages.pc7 /= topo.num_packages;
|
2012-11-21 13:22:43 +00:00
|
|
|
|
|
|
|
average.packages.pc8 /= topo.num_packages;
|
|
|
|
average.packages.pc9 /= topo.num_packages;
|
|
|
|
average.packages.pc10 /= topo.num_packages;
|
2016-12-23 04:57:55 +00:00
|
|
|
|
|
|
|
for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
continue;
|
2017-02-16 02:45:40 +00:00
|
|
|
if (mp->type == COUNTER_ITEMS) {
|
|
|
|
if (average.threads.counter[i] > 9999999)
|
|
|
|
sums_need_wide_columns = 1;
|
2017-02-09 23:25:22 +00:00
|
|
|
continue;
|
2017-02-16 02:45:40 +00:00
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
average.threads.counter[i] /= topo.num_cpus;
|
|
|
|
}
|
|
|
|
for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
continue;
|
2017-02-16 02:45:40 +00:00
|
|
|
if (mp->type == COUNTER_ITEMS) {
|
|
|
|
if (average.cores.counter[i] > 9999999)
|
|
|
|
sums_need_wide_columns = 1;
|
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
average.cores.counter[i] /= topo.num_cores;
|
|
|
|
}
|
|
|
|
for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
|
|
|
|
if (mp->format == FORMAT_RAW)
|
|
|
|
continue;
|
2017-02-16 02:45:40 +00:00
|
|
|
if (mp->type == COUNTER_ITEMS) {
|
|
|
|
if (average.packages.counter[i] > 9999999)
|
|
|
|
sums_need_wide_columns = 1;
|
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
average.packages.counter[i] /= topo.num_packages;
|
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
static unsigned long long rdtsc(void)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
unsigned int low, high;
|
2012-03-30 02:19:58 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
asm volatile("rdtsc" : "=a" (low), "=d" (high));
|
2012-03-30 02:19:58 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return low | ((unsigned long long)high) << 32;
|
|
|
|
}
|
2012-03-30 02:19:58 +00:00
|
|
|
|
2017-02-08 07:41:51 +00:00
|
|
|
/*
|
|
|
|
* Open a file, and exit on failure
|
|
|
|
*/
|
|
|
|
FILE *fopen_or_die(const char *path, const char *mode)
|
|
|
|
{
|
|
|
|
FILE *filep = fopen(path, mode);
|
|
|
|
|
|
|
|
if (!filep)
|
|
|
|
err(1, "%s: open failed", path);
|
|
|
|
return filep;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* snapshot_sysfs_counter()
|
|
|
|
*
|
|
|
|
* return snapshot of given counter
|
|
|
|
*/
|
|
|
|
unsigned long long snapshot_sysfs_counter(char *path)
|
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
int retval;
|
|
|
|
unsigned long long counter;
|
|
|
|
|
|
|
|
fp = fopen_or_die(path, "r");
|
|
|
|
|
|
|
|
retval = fscanf(fp, "%lld", &counter);
|
|
|
|
if (retval != 1)
|
|
|
|
err(1, "snapshot_sysfs_counter(%s)", path);
|
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
return counter;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_mp(int cpu, struct msr_counter *mp, unsigned long long *counterp)
|
|
|
|
{
|
|
|
|
if (mp->msr_num != 0) {
|
|
|
|
if (get_msr(cpu, mp->msr_num, counterp))
|
|
|
|
return -1;
|
|
|
|
} else {
|
2017-12-08 22:38:17 +00:00
|
|
|
char path[128 + PATH_BYTES];
|
2017-02-09 23:25:22 +00:00
|
|
|
|
|
|
|
if (mp->flags & SYSFS_PERCPU) {
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/%s",
|
|
|
|
cpu, mp->path);
|
|
|
|
|
|
|
|
*counterp = snapshot_sysfs_counter(path);
|
|
|
|
} else {
|
|
|
|
*counterp = snapshot_sysfs_counter(mp->path);
|
|
|
|
}
|
2017-02-08 07:41:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-06-06 21:44:48 +00:00
|
|
|
void get_apic_id(struct thread_data *t)
|
|
|
|
{
|
2018-08-08 00:22:28 +00:00
|
|
|
unsigned int eax, ebx, ecx, edx;
|
2018-06-06 21:44:48 +00:00
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
if (DO_BIC(BIC_APIC)) {
|
|
|
|
eax = ebx = ecx = edx = 0;
|
|
|
|
__cpuid(1, eax, ebx, ecx, edx);
|
2018-06-06 21:44:48 +00:00
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
t->apic_id = (ebx >> 24) & 0xff;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!DO_BIC(BIC_X2APIC))
|
2018-06-06 21:44:48 +00:00
|
|
|
return;
|
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
if (authentic_amd) {
|
|
|
|
unsigned int topology_extensions;
|
2018-06-06 21:44:48 +00:00
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
if (max_extended_level < 0x8000001e)
|
|
|
|
return;
|
2018-06-06 21:44:48 +00:00
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
eax = ebx = ecx = edx = 0;
|
|
|
|
__cpuid(0x80000001, eax, ebx, ecx, edx);
|
|
|
|
topology_extensions = ecx & (1 << 22);
|
|
|
|
|
|
|
|
if (topology_extensions == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
eax = ebx = ecx = edx = 0;
|
|
|
|
__cpuid(0x8000001e, eax, ebx, ecx, edx);
|
|
|
|
|
|
|
|
t->x2apic_id = eax;
|
2018-06-06 21:44:48 +00:00
|
|
|
return;
|
2018-08-08 00:22:28 +00:00
|
|
|
}
|
2018-06-06 21:44:48 +00:00
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
if (!genuine_intel)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (max_level < 0xb)
|
2018-06-06 21:44:48 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
ecx = 0;
|
|
|
|
__cpuid(0xb, eax, ebx, ecx, edx);
|
|
|
|
t->x2apic_id = edx;
|
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
if (debug && (t->apic_id != (t->x2apic_id & 0xff)))
|
|
|
|
fprintf(outf, "cpu%d: BIOS BUG: apic 0x%x x2apic 0x%x\n",
|
|
|
|
t->cpu_id, t->apic_id, t->x2apic_id);
|
2018-06-06 21:44:48 +00:00
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/*
|
|
|
|
* get_counters(...)
|
|
|
|
* migrate to cpu
|
|
|
|
* acquire and record local counters for that cpu
|
|
|
|
*/
|
|
|
|
int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
{
|
|
|
|
int cpu = t->cpu_id;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
unsigned long long msr;
|
2016-02-27 08:11:29 +00:00
|
|
|
int aperf_mperf_retry_count = 0;
|
2016-12-23 04:57:55 +00:00
|
|
|
struct msr_counter *mp;
|
|
|
|
int i;
|
2012-03-30 01:44:40 +00:00
|
|
|
|
2012-11-09 03:38:05 +00:00
|
|
|
if (cpu_migrate(cpu)) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "Could not migrate to CPU %d\n", cpu);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return -1;
|
2012-11-09 03:38:05 +00:00
|
|
|
}
|
2012-03-30 02:19:58 +00:00
|
|
|
|
2019-03-25 17:32:42 +00:00
|
|
|
gettimeofday(&t->tv_begin, (struct timezone *)NULL);
|
|
|
|
|
2018-06-06 21:44:48 +00:00
|
|
|
if (first_counter_read)
|
|
|
|
get_apic_id(t);
|
2016-02-27 08:11:29 +00:00
|
|
|
retry:
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
t->tsc = rdtsc(); /* we are running on local CPU of interest */
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_Avg_MHz) || DO_BIC(BIC_Busy) || DO_BIC(BIC_Bzy_MHz)) {
|
2016-02-27 08:11:29 +00:00
|
|
|
unsigned long long tsc_before, tsc_between, tsc_after, aperf_time, mperf_time;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The TSC, APERF and MPERF must be read together for
|
|
|
|
* APERF/MPERF and MPERF/TSC to give accurate results.
|
|
|
|
*
|
|
|
|
* Unfortunately, APERF and MPERF are read by
|
|
|
|
* individual system call, so delays may occur
|
|
|
|
* between them. If the time to read them
|
|
|
|
* varies by a large amount, we re-read them.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This initial dummy APERF read has been seen to
|
|
|
|
* reduce jitter in the subsequent reads.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
|
|
|
|
return -3;
|
|
|
|
|
|
|
|
t->tsc = rdtsc(); /* re-read close to APERF */
|
|
|
|
|
|
|
|
tsc_before = t->tsc;
|
|
|
|
|
2012-10-31 05:29:52 +00:00
|
|
|
if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return -3;
|
2016-02-27 08:11:29 +00:00
|
|
|
|
|
|
|
tsc_between = rdtsc();
|
|
|
|
|
2012-10-31 05:29:52 +00:00
|
|
|
if (get_msr(cpu, MSR_IA32_MPERF, &t->mperf))
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return -4;
|
2016-02-27 08:11:29 +00:00
|
|
|
|
|
|
|
tsc_after = rdtsc();
|
|
|
|
|
|
|
|
aperf_time = tsc_between - tsc_before;
|
|
|
|
mperf_time = tsc_after - tsc_between;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the system call latency to read APERF and MPERF
|
|
|
|
* differ by more than 2x, then try again.
|
|
|
|
*/
|
|
|
|
if ((aperf_time > (2 * mperf_time)) || (mperf_time > (2 * aperf_time))) {
|
|
|
|
aperf_mperf_retry_count++;
|
|
|
|
if (aperf_mperf_retry_count < 5)
|
|
|
|
goto retry;
|
|
|
|
else
|
|
|
|
warnx("cpu%d jitter %lld %lld",
|
|
|
|
cpu, aperf_time, mperf_time);
|
|
|
|
}
|
|
|
|
aperf_mperf_retry_count = 0;
|
|
|
|
|
2015-09-14 11:31:00 +00:00
|
|
|
t->aperf = t->aperf * aperf_mperf_multiplier;
|
|
|
|
t->mperf = t->mperf * aperf_mperf_multiplier;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_IRQ))
|
2016-02-27 04:48:05 +00:00
|
|
|
t->irq_count = irqs_per_cpu[cpu];
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_SMI)) {
|
2013-02-10 22:19:24 +00:00
|
|
|
if (get_msr(cpu, MSR_SMI_COUNT, &msr))
|
|
|
|
return -5;
|
|
|
|
t->smi_count = msr & 0xFFFFFFFF;
|
|
|
|
}
|
2017-02-10 05:27:20 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c1) && use_c1_residency_msr) {
|
2013-11-09 05:30:16 +00:00
|
|
|
if (get_msr(cpu, MSR_CORE_C1_RES, &t->c1))
|
|
|
|
return -6;
|
|
|
|
}
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.tp; mp; i++, mp = mp->next) {
|
2017-02-08 07:41:51 +00:00
|
|
|
if (get_mp(cpu, mp, &t->counter[i]))
|
2016-12-23 04:57:55 +00:00
|
|
|
return -10;
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* collect core counters only for 1st thread in core */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
|
2017-05-28 04:06:55 +00:00
|
|
|
goto done;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2019-03-19 21:52:32 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c3)) {
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3))
|
|
|
|
return -6;
|
2013-11-09 05:30:16 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c6) && !do_knl_cstates) {
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (get_msr(cpu, MSR_CORE_C6_RESIDENCY, &c->c6))
|
|
|
|
return -7;
|
2015-05-20 16:49:34 +00:00
|
|
|
} else if (do_knl_cstates) {
|
|
|
|
if (get_msr(cpu, MSR_KNL_CORE_C6_RESIDENCY, &c->c6))
|
|
|
|
return -7;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CPU_c7))
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (get_msr(cpu, MSR_CORE_C7_RESIDENCY, &c->c7))
|
|
|
|
return -8;
|
|
|
|
|
2017-02-10 05:27:20 +00:00
|
|
|
if (DO_BIC(BIC_Mod_c6))
|
|
|
|
if (get_msr(cpu, MSR_MODULE_C6_RES_MS, &c->mc6_us))
|
|
|
|
return -8;
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_CoreTmp)) {
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
|
|
|
|
return -9;
|
|
|
|
c->core_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
|
|
|
|
}
|
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
if (do_rapl & RAPL_AMD_F17H) {
|
|
|
|
if (get_msr(cpu, MSR_CORE_ENERGY_STAT, &msr))
|
|
|
|
return -14;
|
|
|
|
c->core_energy = msr & 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.cp; mp; i++, mp = mp->next) {
|
2017-02-08 07:41:51 +00:00
|
|
|
if (get_mp(cpu, mp, &c->counter[i]))
|
2016-12-23 04:57:55 +00:00
|
|
|
return -10;
|
|
|
|
}
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* collect package counters only for 1st core in package */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
2017-05-28 04:06:55 +00:00
|
|
|
goto done;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2017-05-21 00:11:55 +00:00
|
|
|
if (DO_BIC(BIC_Totl_c0)) {
|
2015-03-26 04:50:30 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_WEIGHTED_CORE_C0_RES, &p->pkg_wtd_core_c0))
|
|
|
|
return -10;
|
2017-05-21 00:11:55 +00:00
|
|
|
}
|
|
|
|
if (DO_BIC(BIC_Any_c0)) {
|
2015-03-26 04:50:30 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_ANY_CORE_C0_RES, &p->pkg_any_core_c0))
|
|
|
|
return -11;
|
2017-05-21 00:11:55 +00:00
|
|
|
}
|
|
|
|
if (DO_BIC(BIC_GFX_c0)) {
|
2015-03-26 04:50:30 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_ANY_GFXE_C0_RES, &p->pkg_any_gfxe_c0))
|
|
|
|
return -12;
|
2017-05-21 00:11:55 +00:00
|
|
|
}
|
|
|
|
if (DO_BIC(BIC_CPUGFX)) {
|
2015-03-26 04:50:30 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_BOTH_CORE_GFXE_C0_RES, &p->pkg_both_core_gfxe_c0))
|
|
|
|
return -13;
|
|
|
|
}
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc3))
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
|
|
|
|
return -9;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc6)) {
|
2017-02-10 05:27:20 +00:00
|
|
|
if (do_slm_cstates) {
|
|
|
|
if (get_msr(cpu, MSR_ATOM_PKG_C6_RESIDENCY, &p->pc6))
|
|
|
|
return -10;
|
|
|
|
} else {
|
|
|
|
if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
|
|
|
|
return -10;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc2))
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
|
|
|
|
return -11;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc7))
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
|
|
|
|
return -12;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc8))
|
2012-11-21 13:22:43 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_C8_RESIDENCY, &p->pc8))
|
|
|
|
return -13;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc9))
|
2012-11-21 13:22:43 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_C9_RESIDENCY, &p->pc9))
|
|
|
|
return -13;
|
2017-01-27 05:50:45 +00:00
|
|
|
if (DO_BIC(BIC_Pkgpc10))
|
2012-11-21 13:22:43 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_C10_RESIDENCY, &p->pc10))
|
|
|
|
return -13;
|
2017-01-27 05:50:45 +00:00
|
|
|
|
2018-06-01 16:35:53 +00:00
|
|
|
if (DO_BIC(BIC_CPU_LPI))
|
|
|
|
p->cpu_lpi = cpuidle_cur_cpu_lpi_us;
|
|
|
|
if (DO_BIC(BIC_SYS_LPI))
|
|
|
|
p->sys_lpi = cpuidle_cur_sys_lpi_us;
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
if (do_rapl & RAPL_PKG) {
|
|
|
|
if (get_msr(cpu, MSR_PKG_ENERGY_STATUS, &msr))
|
|
|
|
return -13;
|
|
|
|
p->energy_pkg = msr & 0xFFFFFFFF;
|
|
|
|
}
|
2016-06-16 16:48:20 +00:00
|
|
|
if (do_rapl & RAPL_CORES_ENERGY_STATUS) {
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
if (get_msr(cpu, MSR_PP0_ENERGY_STATUS, &msr))
|
|
|
|
return -14;
|
|
|
|
p->energy_cores = msr & 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
if (do_rapl & RAPL_DRAM) {
|
|
|
|
if (get_msr(cpu, MSR_DRAM_ENERGY_STATUS, &msr))
|
|
|
|
return -15;
|
|
|
|
p->energy_dram = msr & 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
if (do_rapl & RAPL_GFX) {
|
|
|
|
if (get_msr(cpu, MSR_PP1_ENERGY_STATUS, &msr))
|
|
|
|
return -16;
|
|
|
|
p->energy_gfx = msr & 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
if (do_rapl & RAPL_PKG_PERF_STATUS) {
|
|
|
|
if (get_msr(cpu, MSR_PKG_PERF_STATUS, &msr))
|
|
|
|
return -16;
|
|
|
|
p->rapl_pkg_perf_status = msr & 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
if (do_rapl & RAPL_DRAM_PERF_STATUS) {
|
|
|
|
if (get_msr(cpu, MSR_DRAM_PERF_STATUS, &msr))
|
|
|
|
return -16;
|
|
|
|
p->rapl_dram_perf_status = msr & 0xFFFFFFFF;
|
|
|
|
}
|
2018-08-17 16:34:42 +00:00
|
|
|
if (do_rapl & RAPL_AMD_F17H) {
|
|
|
|
if (get_msr(cpu, MSR_PKG_ENERGY_STAT, &msr))
|
|
|
|
return -13;
|
|
|
|
p->energy_pkg = msr & 0xFFFFFFFF;
|
|
|
|
}
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_PkgTmp)) {
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
|
|
|
|
return -17;
|
|
|
|
p->pkg_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
|
|
|
|
}
|
2016-02-27 06:28:12 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFX_rc6))
|
2016-02-27 06:28:12 +00:00
|
|
|
p->gfx_rc6_ms = gfx_cur_rc6_ms;
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFXMHz))
|
2016-02-27 05:37:54 +00:00
|
|
|
p->gfx_mhz = gfx_cur_mhz;
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
for (i = 0, mp = sys.pp; mp; i++, mp = mp->next) {
|
2017-02-08 07:41:51 +00:00
|
|
|
if (get_mp(cpu, mp, &p->counter[i]))
|
2016-12-23 04:57:55 +00:00
|
|
|
return -10;
|
|
|
|
}
|
2017-05-28 04:06:55 +00:00
|
|
|
done:
|
|
|
|
gettimeofday(&t->tv_end, (struct timezone *)NULL);
|
2016-12-23 04:57:55 +00:00
|
|
|
|
2012-03-30 02:19:58 +00:00
|
|
|
return 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2015-02-10 04:39:45 +00:00
|
|
|
/*
|
|
|
|
* MSR_PKG_CST_CONFIG_CONTROL decoding for pkg_cstate_limit:
|
|
|
|
* If you change the values, note they are used both in comparisons
|
|
|
|
* (>= PCL__7) and to index pkg_cstate_limit_strings[].
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define PCLUKN 0 /* Unknown */
|
|
|
|
#define PCLRSV 1 /* Reserved */
|
|
|
|
#define PCL__0 2 /* PC0 */
|
|
|
|
#define PCL__1 3 /* PC1 */
|
|
|
|
#define PCL__2 4 /* PC2 */
|
|
|
|
#define PCL__3 5 /* PC3 */
|
|
|
|
#define PCL__4 6 /* PC4 */
|
|
|
|
#define PCL__6 7 /* PC6 */
|
|
|
|
#define PCL_6N 8 /* PC6 No Retention */
|
|
|
|
#define PCL_6R 9 /* PC6 Retention */
|
|
|
|
#define PCL__7 10 /* PC7 */
|
|
|
|
#define PCL_7S 11 /* PC7 Shrink */
|
2015-03-26 04:50:30 +00:00
|
|
|
#define PCL__8 12 /* PC8 */
|
|
|
|
#define PCL__9 13 /* PC9 */
|
2018-12-15 01:02:27 +00:00
|
|
|
#define PCL_10 14 /* PC10 */
|
|
|
|
#define PCLUNL 15 /* Unlimited */
|
2015-02-10 04:39:45 +00:00
|
|
|
|
|
|
|
int pkg_cstate_limit = PCLUKN;
|
|
|
|
char *pkg_cstate_limit_strings[] = { "reserved", "unknown", "pc0", "pc1", "pc2",
|
2018-12-15 01:02:27 +00:00
|
|
|
"pc3", "pc4", "pc6", "pc6n", "pc6r", "pc7", "pc7s", "pc8", "pc9", "pc10", "unlimited"};
|
2015-02-10 04:39:45 +00:00
|
|
|
|
2015-04-02 01:02:57 +00:00
|
|
|
int nhm_pkg_cstate_limits[16] = {PCL__0, PCL__1, PCL__3, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
|
|
|
|
int snb_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCL__7, PCL_7S, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
|
|
|
|
int hsw_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL__3, PCL__6, PCL__7, PCL_7S, PCL__8, PCL__9, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
|
2017-02-10 05:27:20 +00:00
|
|
|
int slv_pkg_cstate_limits[16] = {PCL__0, PCL__1, PCLRSV, PCLRSV, PCL__4, PCLRSV, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCL__6, PCL__7};
|
2017-01-08 04:13:15 +00:00
|
|
|
int amt_pkg_cstate_limits[16] = {PCLUNL, PCL__1, PCL__2, PCLRSV, PCLRSV, PCLRSV, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
|
2015-04-02 01:02:57 +00:00
|
|
|
int phi_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCLRSV, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
|
2018-12-15 01:02:27 +00:00
|
|
|
int glm_pkg_cstate_limits[16] = {PCLUNL, PCL__1, PCL__3, PCL__6, PCL__7, PCL_7S, PCL__8, PCL__9, PCL_10, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
|
2017-08-04 15:42:23 +00:00
|
|
|
int skx_pkg_cstate_limits[16] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCLRSV, PCLRSV, PCLRSV, PCLUNL, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV, PCLRSV};
|
2015-02-10 04:39:45 +00:00
|
|
|
|
2015-09-26 04:12:38 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
calculate_tsc_tweak()
|
|
|
|
{
|
|
|
|
tsc_tweak = base_hz / tsc_hz;
|
|
|
|
}
|
|
|
|
|
2015-03-24 00:29:09 +00:00
|
|
|
static void
|
|
|
|
dump_nhm_platform_info(void)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
unsigned int ratio;
|
|
|
|
|
2015-11-12 07:42:31 +00:00
|
|
|
get_msr(base_cpu, MSR_PLATFORM_INFO, &msr);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_PLATFORM_INFO: 0x%08llx\n", base_cpu, msr);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
ratio = (msr >> 40) & 0xFF;
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max efficiency frequency\n",
|
2010-10-23 03:53:03 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0xFF;
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz base frequency\n",
|
2010-10-23 03:53:03 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
2015-05-25 12:34:28 +00:00
|
|
|
get_msr(base_cpu, MSR_IA32_POWER_CTL, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_POWER_CTL: 0x%08llx (C1E auto-promotion: %sabled)\n",
|
2015-06-17 16:27:21 +00:00
|
|
|
base_cpu, msr, msr & 0x2 ? "EN" : "DIS");
|
2013-01-31 20:22:15 +00:00
|
|
|
|
2015-03-24 00:29:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
dump_hsw_turbo_ratio_limits(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
unsigned int ratio;
|
|
|
|
|
2015-05-25 12:34:28 +00:00
|
|
|
get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT2, &msr);
|
2015-03-24 00:29:09 +00:00
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT2: 0x%08llx\n", base_cpu, msr);
|
2015-03-24 00:29:09 +00:00
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 18 active cores\n",
|
2015-03-24 00:29:09 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 0) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 17 active cores\n",
|
2015-03-24 00:29:09 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
dump_ivt_turbo_ratio_limits(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
unsigned int ratio;
|
2012-09-21 04:01:31 +00:00
|
|
|
|
2015-05-25 12:34:28 +00:00
|
|
|
get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT1, &msr);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT1: 0x%08llx\n", base_cpu, msr);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
|
|
|
ratio = (msr >> 56) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 16 active cores\n",
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 48) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 15 active cores\n",
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 40) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 14 active cores\n",
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 32) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 13 active cores\n",
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 24) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 12 active cores\n",
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 16) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 11 active cores\n",
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 10 active cores\n",
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 0) & 0xFF;
|
|
|
|
if (ratio)
|
2017-01-12 03:12:25 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 9 active cores\n",
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio, bclk, ratio * bclk);
|
2015-03-24 00:29:09 +00:00
|
|
|
return;
|
|
|
|
}
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
int has_turbo_ratio_group_limits(int family, int model)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT:
|
|
|
|
case INTEL_FAM6_SKYLAKE_X:
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_X:
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2012-09-21 04:01:31 +00:00
|
|
|
|
2015-03-24 00:29:09 +00:00
|
|
|
static void
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
dump_turbo_ratio_limits(int family, int model)
|
2015-03-24 00:29:09 +00:00
|
|
|
{
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
unsigned long long msr, core_counts;
|
|
|
|
unsigned int ratio, group_size;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-05-25 12:34:28 +00:00
|
|
|
get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n", base_cpu, msr);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
if (has_turbo_ratio_group_limits(family, model)) {
|
|
|
|
get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT1, &core_counts);
|
|
|
|
fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT1: 0x%08llx\n", base_cpu, core_counts);
|
|
|
|
} else {
|
|
|
|
core_counts = 0x0807060504030201;
|
|
|
|
}
|
|
|
|
|
2012-09-21 04:01:31 +00:00
|
|
|
ratio = (msr >> 56) & 0xFF;
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
group_size = (core_counts >> 56) & 0xFF;
|
2012-09-21 04:01:31 +00:00
|
|
|
if (ratio)
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk, group_size);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
|
|
|
ratio = (msr >> 48) & 0xFF;
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
group_size = (core_counts >> 48) & 0xFF;
|
2012-09-21 04:01:31 +00:00
|
|
|
if (ratio)
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk, group_size);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
|
|
|
ratio = (msr >> 40) & 0xFF;
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
group_size = (core_counts >> 40) & 0xFF;
|
2012-09-21 04:01:31 +00:00
|
|
|
if (ratio)
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk, group_size);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
|
|
|
ratio = (msr >> 32) & 0xFF;
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
group_size = (core_counts >> 32) & 0xFF;
|
2012-09-21 04:01:31 +00:00
|
|
|
if (ratio)
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk, group_size);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
ratio = (msr >> 24) & 0xFF;
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
group_size = (core_counts >> 24) & 0xFF;
|
2010-10-23 03:53:03 +00:00
|
|
|
if (ratio)
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk, group_size);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
ratio = (msr >> 16) & 0xFF;
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
group_size = (core_counts >> 16) & 0xFF;
|
2010-10-23 03:53:03 +00:00
|
|
|
if (ratio)
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk, group_size);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0xFF;
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
group_size = (core_counts >> 8) & 0xFF;
|
2010-10-23 03:53:03 +00:00
|
|
|
if (ratio)
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk, group_size);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
ratio = (msr >> 0) & 0xFF;
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
group_size = (core_counts >> 0) & 0xFF;
|
2010-10-23 03:53:03 +00:00
|
|
|
if (ratio)
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk, group_size);
|
2015-03-24 00:29:09 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-08-15 06:39:52 +00:00
|
|
|
|
2017-01-13 04:49:18 +00:00
|
|
|
static void
|
|
|
|
dump_atom_turbo_ratio_limits(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
unsigned int ratio;
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_ATOM_CORE_RATIOS, &msr);
|
|
|
|
fprintf(outf, "cpu%d: MSR_ATOM_CORE_RATIOS: 0x%08llx\n", base_cpu, msr & 0xFFFFFFFF);
|
|
|
|
|
|
|
|
ratio = (msr >> 0) & 0x3F;
|
|
|
|
if (ratio)
|
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz minimum operating frequency\n",
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0x3F;
|
|
|
|
if (ratio)
|
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz low frequency mode (LFM)\n",
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 16) & 0x3F;
|
|
|
|
if (ratio)
|
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz base frequency\n",
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_ATOM_CORE_TURBO_RATIOS, &msr);
|
|
|
|
fprintf(outf, "cpu%d: MSR_ATOM_CORE_TURBO_RATIOS: 0x%08llx\n", base_cpu, msr & 0xFFFFFFFF);
|
|
|
|
|
|
|
|
ratio = (msr >> 24) & 0x3F;
|
|
|
|
if (ratio)
|
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 4 active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 16) & 0x3F;
|
|
|
|
if (ratio)
|
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 3 active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0x3F;
|
|
|
|
if (ratio)
|
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 2 active cores\n",
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
ratio = (msr >> 0) & 0x3F;
|
|
|
|
if (ratio)
|
|
|
|
fprintf(outf, "%d * %.1f = %.1f MHz max turbo 1 active core\n",
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
}
|
|
|
|
|
2015-05-20 16:49:34 +00:00
|
|
|
static void
|
|
|
|
dump_knl_turbo_ratio_limits(void)
|
|
|
|
{
|
2016-02-10 13:55:22 +00:00
|
|
|
const unsigned int buckets_no = 7;
|
|
|
|
|
2015-05-20 16:49:34 +00:00
|
|
|
unsigned long long msr;
|
2016-02-10 13:55:22 +00:00
|
|
|
int delta_cores, delta_ratio;
|
|
|
|
int i, b_nr;
|
|
|
|
unsigned int cores[buckets_no];
|
|
|
|
unsigned int ratio[buckets_no];
|
2015-05-20 16:49:34 +00:00
|
|
|
|
2016-07-06 23:07:56 +00:00
|
|
|
get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
|
2015-05-20 16:49:34 +00:00
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n",
|
2015-06-17 16:27:21 +00:00
|
|
|
base_cpu, msr);
|
2015-05-20 16:49:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Turbo encoding in KNL is as follows:
|
2016-02-10 13:55:22 +00:00
|
|
|
* [0] -- Reserved
|
|
|
|
* [7:1] -- Base value of number of active cores of bucket 1.
|
2015-05-20 16:49:34 +00:00
|
|
|
* [15:8] -- Base value of freq ratio of bucket 1.
|
|
|
|
* [20:16] -- +ve delta of number of active cores of bucket 2.
|
|
|
|
* i.e. active cores of bucket 2 =
|
|
|
|
* active cores of bucket 1 + delta
|
|
|
|
* [23:21] -- Negative delta of freq ratio of bucket 2.
|
|
|
|
* i.e. freq ratio of bucket 2 =
|
|
|
|
* freq ratio of bucket 1 - delta
|
|
|
|
* [28:24]-- +ve delta of number of active cores of bucket 3.
|
|
|
|
* [31:29]-- -ve delta of freq ratio of bucket 3.
|
|
|
|
* [36:32]-- +ve delta of number of active cores of bucket 4.
|
|
|
|
* [39:37]-- -ve delta of freq ratio of bucket 4.
|
|
|
|
* [44:40]-- +ve delta of number of active cores of bucket 5.
|
|
|
|
* [47:45]-- -ve delta of freq ratio of bucket 5.
|
|
|
|
* [52:48]-- +ve delta of number of active cores of bucket 6.
|
|
|
|
* [55:53]-- -ve delta of freq ratio of bucket 6.
|
|
|
|
* [60:56]-- +ve delta of number of active cores of bucket 7.
|
|
|
|
* [63:61]-- -ve delta of freq ratio of bucket 7.
|
|
|
|
*/
|
2016-02-10 13:55:22 +00:00
|
|
|
|
|
|
|
b_nr = 0;
|
|
|
|
cores[b_nr] = (msr & 0xFF) >> 1;
|
|
|
|
ratio[b_nr] = (msr >> 8) & 0xFF;
|
|
|
|
|
|
|
|
for (i = 16; i < 64; i += 8) {
|
2015-05-20 16:49:34 +00:00
|
|
|
delta_cores = (msr >> i) & 0x1F;
|
2016-02-10 13:55:22 +00:00
|
|
|
delta_ratio = (msr >> (i + 5)) & 0x7;
|
|
|
|
|
|
|
|
cores[b_nr + 1] = cores[b_nr] + delta_cores;
|
|
|
|
ratio[b_nr + 1] = ratio[b_nr] - delta_ratio;
|
|
|
|
b_nr++;
|
2015-05-20 16:49:34 +00:00
|
|
|
}
|
2016-02-10 13:55:22 +00:00
|
|
|
|
|
|
|
for (i = buckets_no - 1; i >= 0; i--)
|
|
|
|
if (i > 0 ? ratio[i] != ratio[i - 1] : 1)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf,
|
2017-01-12 03:12:25 +00:00
|
|
|
"%d * %.1f = %.1f MHz max turbo %d active cores\n",
|
2016-02-10 13:55:22 +00:00
|
|
|
ratio[i], bclk, ratio[i] * bclk, cores[i]);
|
2015-05-20 16:49:34 +00:00
|
|
|
}
|
|
|
|
|
2015-03-24 00:29:09 +00:00
|
|
|
static void
|
|
|
|
dump_nhm_cst_cfg(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
2017-01-08 04:24:57 +00:00
|
|
|
get_msr(base_cpu, MSR_PKG_CST_CONFIG_CONTROL, &msr);
|
2015-03-24 00:29:09 +00:00
|
|
|
|
2017-01-08 04:24:57 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_PKG_CST_CONFIG_CONTROL: 0x%08llx", base_cpu, msr);
|
2015-03-24 00:29:09 +00:00
|
|
|
|
2017-09-05 12:25:42 +00:00
|
|
|
fprintf(outf, " (%s%s%s%s%slocked, pkg-cstate-limit=%d (%s)",
|
2015-03-24 00:29:09 +00:00
|
|
|
(msr & SNB_C3_AUTO_UNDEMOTE) ? "UNdemote-C3, " : "",
|
|
|
|
(msr & SNB_C1_AUTO_UNDEMOTE) ? "UNdemote-C1, " : "",
|
|
|
|
(msr & NHM_C3_AUTO_DEMOTE) ? "demote-C3, " : "",
|
|
|
|
(msr & NHM_C1_AUTO_DEMOTE) ? "demote-C1, " : "",
|
|
|
|
(msr & (1 << 15)) ? "" : "UN",
|
2016-03-13 07:21:22 +00:00
|
|
|
(unsigned int)msr & 0xF,
|
2015-03-24 00:29:09 +00:00
|
|
|
pkg_cstate_limit_strings[pkg_cstate_limit]);
|
2017-09-05 12:14:08 +00:00
|
|
|
|
|
|
|
#define AUTOMATIC_CSTATE_CONVERSION (1UL << 16)
|
|
|
|
if (has_automatic_cstate_conversion) {
|
|
|
|
fprintf(outf, ", automatic c-state conversion=%s",
|
|
|
|
(msr & AUTOMATIC_CSTATE_CONVERSION) ? "on" : "off");
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(outf, ")\n");
|
|
|
|
|
2015-03-24 00:29:09 +00:00
|
|
|
return;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2015-06-17 20:23:45 +00:00
|
|
|
static void
|
|
|
|
dump_config_tdp(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_CONFIG_TDP_NOMINAL, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_CONFIG_TDP_NOMINAL: 0x%08llx", base_cpu, msr);
|
2015-12-13 13:09:31 +00:00
|
|
|
fprintf(outf, " (base_ratio=%d)\n", (unsigned int)msr & 0xFF);
|
2015-06-17 20:23:45 +00:00
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_CONFIG_TDP_LEVEL_1, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_CONFIG_TDP_LEVEL_1: 0x%08llx (", base_cpu, msr);
|
2015-06-17 20:23:45 +00:00
|
|
|
if (msr) {
|
2015-12-13 13:09:31 +00:00
|
|
|
fprintf(outf, "PKG_MIN_PWR_LVL1=%d ", (unsigned int)(msr >> 48) & 0x7FFF);
|
|
|
|
fprintf(outf, "PKG_MAX_PWR_LVL1=%d ", (unsigned int)(msr >> 32) & 0x7FFF);
|
|
|
|
fprintf(outf, "LVL1_RATIO=%d ", (unsigned int)(msr >> 16) & 0xFF);
|
|
|
|
fprintf(outf, "PKG_TDP_LVL1=%d", (unsigned int)(msr) & 0x7FFF);
|
2015-06-17 20:23:45 +00:00
|
|
|
}
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, ")\n");
|
2015-06-17 20:23:45 +00:00
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_CONFIG_TDP_LEVEL_2, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_CONFIG_TDP_LEVEL_2: 0x%08llx (", base_cpu, msr);
|
2015-06-17 20:23:45 +00:00
|
|
|
if (msr) {
|
2015-12-13 13:09:31 +00:00
|
|
|
fprintf(outf, "PKG_MIN_PWR_LVL2=%d ", (unsigned int)(msr >> 48) & 0x7FFF);
|
|
|
|
fprintf(outf, "PKG_MAX_PWR_LVL2=%d ", (unsigned int)(msr >> 32) & 0x7FFF);
|
|
|
|
fprintf(outf, "LVL2_RATIO=%d ", (unsigned int)(msr >> 16) & 0xFF);
|
|
|
|
fprintf(outf, "PKG_TDP_LVL2=%d", (unsigned int)(msr) & 0x7FFF);
|
2015-06-17 20:23:45 +00:00
|
|
|
}
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, ")\n");
|
2015-06-17 20:23:45 +00:00
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_CONFIG_TDP_CONTROL, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_CONFIG_TDP_CONTROL: 0x%08llx (", base_cpu, msr);
|
2015-06-17 20:23:45 +00:00
|
|
|
if ((msr) & 0x3)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "TDP_LEVEL=%d ", (unsigned int)(msr) & 0x3);
|
|
|
|
fprintf(outf, " lock=%d", (unsigned int)(msr >> 31) & 1);
|
|
|
|
fprintf(outf, ")\n");
|
2016-02-27 01:51:02 +00:00
|
|
|
|
2015-06-17 20:23:45 +00:00
|
|
|
get_msr(base_cpu, MSR_TURBO_ACTIVATION_RATIO, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_TURBO_ACTIVATION_RATIO: 0x%08llx (", base_cpu, msr);
|
2015-12-13 13:09:31 +00:00
|
|
|
fprintf(outf, "MAX_NON_TURBO_RATIO=%d", (unsigned int)(msr) & 0xFF);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, " lock=%d", (unsigned int)(msr >> 31) & 1);
|
|
|
|
fprintf(outf, ")\n");
|
2015-06-17 20:23:45 +00:00
|
|
|
}
|
2016-04-06 21:15:55 +00:00
|
|
|
|
|
|
|
unsigned int irtl_time_units[] = {1, 32, 1024, 32768, 1048576, 33554432, 0, 0 };
|
|
|
|
|
|
|
|
void print_irtl(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_PKGC3_IRTL, &msr);
|
|
|
|
fprintf(outf, "cpu%d: MSR_PKGC3_IRTL: 0x%08llx (", base_cpu, msr);
|
|
|
|
fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
|
|
|
|
(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_PKGC6_IRTL, &msr);
|
|
|
|
fprintf(outf, "cpu%d: MSR_PKGC6_IRTL: 0x%08llx (", base_cpu, msr);
|
|
|
|
fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
|
|
|
|
(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_PKGC7_IRTL, &msr);
|
|
|
|
fprintf(outf, "cpu%d: MSR_PKGC7_IRTL: 0x%08llx (", base_cpu, msr);
|
|
|
|
fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
|
|
|
|
(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
|
|
|
|
|
|
|
|
if (!do_irtl_hsw)
|
|
|
|
return;
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_PKGC8_IRTL, &msr);
|
|
|
|
fprintf(outf, "cpu%d: MSR_PKGC8_IRTL: 0x%08llx (", base_cpu, msr);
|
|
|
|
fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
|
|
|
|
(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_PKGC9_IRTL, &msr);
|
|
|
|
fprintf(outf, "cpu%d: MSR_PKGC9_IRTL: 0x%08llx (", base_cpu, msr);
|
|
|
|
fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
|
|
|
|
(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
|
|
|
|
|
|
|
|
get_msr(base_cpu, MSR_PKGC10_IRTL, &msr);
|
|
|
|
fprintf(outf, "cpu%d: MSR_PKGC10_IRTL: 0x%08llx (", base_cpu, msr);
|
|
|
|
fprintf(outf, "%svalid, %lld ns)\n", msr & (1 << 15) ? "" : "NOT",
|
|
|
|
(msr & 0x3FF) * irtl_time_units[(msr >> 10) & 0x3]);
|
|
|
|
|
|
|
|
}
|
2016-02-27 01:51:02 +00:00
|
|
|
void free_fd_percpu(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2016-04-22 08:13:23 +00:00
|
|
|
for (i = 0; i < topo.max_cpu_num + 1; ++i) {
|
2016-02-27 01:51:02 +00:00
|
|
|
if (fd_percpu[i] != 0)
|
|
|
|
close(fd_percpu[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(fd_percpu);
|
2015-06-17 20:23:45 +00:00
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
void free_all_buffers(void)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2018-06-02 02:08:58 +00:00
|
|
|
int i;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
CPU_FREE(cpu_present_set);
|
|
|
|
cpu_present_set = NULL;
|
2016-02-27 01:51:02 +00:00
|
|
|
cpu_present_setsize = 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
CPU_FREE(cpu_affinity_set);
|
|
|
|
cpu_affinity_set = NULL;
|
|
|
|
cpu_affinity_setsize = 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
free(thread_even);
|
|
|
|
free(core_even);
|
|
|
|
free(package_even);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
thread_even = NULL;
|
|
|
|
core_even = NULL;
|
|
|
|
package_even = NULL;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
free(thread_odd);
|
|
|
|
free(core_odd);
|
|
|
|
free(package_odd);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
thread_odd = NULL;
|
|
|
|
core_odd = NULL;
|
|
|
|
package_odd = NULL;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
free(output_buffer);
|
|
|
|
output_buffer = NULL;
|
|
|
|
outp = NULL;
|
2016-02-27 01:51:02 +00:00
|
|
|
|
|
|
|
free_fd_percpu();
|
2016-02-27 04:48:05 +00:00
|
|
|
|
|
|
|
free(irq_column_2_cpu);
|
|
|
|
free(irqs_per_cpu);
|
2018-06-02 02:08:58 +00:00
|
|
|
|
|
|
|
for (i = 0; i <= topo.max_cpu_num; ++i) {
|
|
|
|
if (cpus[i].put_ids)
|
|
|
|
CPU_FREE(cpus[i].put_ids);
|
|
|
|
}
|
|
|
|
free(cpus);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2013-08-21 00:20:17 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/*
|
2013-08-21 00:20:16 +00:00
|
|
|
* Parse a file containing a single int.
|
2019-02-15 03:17:40 +00:00
|
|
|
* Return 0 if file can not be opened
|
|
|
|
* Exit if file can be opened, but can not be parsed
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
*/
|
2013-08-21 00:20:16 +00:00
|
|
|
int parse_int_file(const char *fmt, ...)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2013-08-21 00:20:16 +00:00
|
|
|
va_list args;
|
|
|
|
char path[PATH_MAX];
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
FILE *filep;
|
2013-08-21 00:20:16 +00:00
|
|
|
int value;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2013-08-21 00:20:16 +00:00
|
|
|
va_start(args, fmt);
|
|
|
|
vsnprintf(path, sizeof(path), fmt, args);
|
|
|
|
va_end(args);
|
2019-02-15 03:17:40 +00:00
|
|
|
filep = fopen(path, "r");
|
|
|
|
if (!filep)
|
|
|
|
return 0;
|
2013-08-21 00:20:18 +00:00
|
|
|
if (fscanf(filep, "%d", &value) != 1)
|
|
|
|
err(1, "%s: failed to parse number from file", path);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
fclose(filep);
|
2013-08-21 00:20:16 +00:00
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/*
|
|
|
|
* cpu_is_first_core_in_package(cpu)
|
|
|
|
* return 1 if given CPU is 1st core in package
|
|
|
|
*/
|
|
|
|
int cpu_is_first_core_in_package(int cpu)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2013-08-21 00:20:16 +00:00
|
|
|
return cpu == parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_siblings_list", cpu);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int get_physical_package_id(int cpu)
|
|
|
|
{
|
2013-08-21 00:20:16 +00:00
|
|
|
return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2019-02-15 03:17:40 +00:00
|
|
|
int get_die_id(int cpu)
|
|
|
|
{
|
|
|
|
return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/die_id", cpu);
|
|
|
|
}
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
int get_core_id(int cpu)
|
|
|
|
{
|
2013-08-21 00:20:16 +00:00
|
|
|
return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_id", cpu);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2018-06-01 14:04:30 +00:00
|
|
|
void set_node_data(void)
|
|
|
|
{
|
2018-07-26 13:08:54 +00:00
|
|
|
int pkg, node, lnode, cpu, cpux;
|
|
|
|
int cpu_count;
|
|
|
|
|
|
|
|
/* initialize logical_node_id */
|
|
|
|
for (cpu = 0; cpu <= topo.max_cpu_num; ++cpu)
|
|
|
|
cpus[cpu].logical_node_id = -1;
|
|
|
|
|
|
|
|
cpu_count = 0;
|
|
|
|
for (pkg = 0; pkg < topo.num_packages; pkg++) {
|
|
|
|
lnode = 0;
|
|
|
|
for (cpu = 0; cpu <= topo.max_cpu_num; ++cpu) {
|
|
|
|
if (cpus[cpu].physical_package_id != pkg)
|
|
|
|
continue;
|
|
|
|
/* find a cpu with an unset logical_node_id */
|
|
|
|
if (cpus[cpu].logical_node_id != -1)
|
|
|
|
continue;
|
|
|
|
cpus[cpu].logical_node_id = lnode;
|
|
|
|
node = cpus[cpu].physical_node_id;
|
|
|
|
cpu_count++;
|
|
|
|
/*
|
|
|
|
* find all matching cpus on this pkg and set
|
|
|
|
* the logical_node_id
|
|
|
|
*/
|
|
|
|
for (cpux = cpu; cpux <= topo.max_cpu_num; cpux++) {
|
|
|
|
if ((cpus[cpux].physical_package_id == pkg) &&
|
|
|
|
(cpus[cpux].physical_node_id == node)) {
|
|
|
|
cpus[cpux].logical_node_id = lnode;
|
|
|
|
cpu_count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
lnode++;
|
|
|
|
if (lnode > topo.nodes_per_pkg)
|
|
|
|
topo.nodes_per_pkg = lnode;
|
|
|
|
}
|
|
|
|
if (cpu_count >= topo.max_cpu_num)
|
|
|
|
break;
|
2018-06-01 14:04:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_physical_node_id(struct cpu_topology *thiscpu)
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
{
|
|
|
|
char path[80];
|
|
|
|
FILE *filep;
|
2018-06-02 02:08:58 +00:00
|
|
|
int i;
|
|
|
|
int cpu = thiscpu->logical_cpu_id;
|
2015-04-15 17:09:50 +00:00
|
|
|
|
2018-06-02 02:08:58 +00:00
|
|
|
for (i = 0; i <= topo.max_cpu_num; i++) {
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/node%i/cpulist",
|
|
|
|
cpu, i);
|
|
|
|
filep = fopen(path, "r");
|
|
|
|
if (!filep)
|
|
|
|
continue;
|
|
|
|
fclose(filep);
|
|
|
|
return i;
|
2015-04-15 17:09:50 +00:00
|
|
|
}
|
2018-06-02 02:08:58 +00:00
|
|
|
return -1;
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2018-06-02 02:08:58 +00:00
|
|
|
int get_thread_siblings(struct cpu_topology *thiscpu)
|
|
|
|
{
|
|
|
|
char path[80], character;
|
|
|
|
FILE *filep;
|
|
|
|
unsigned long map;
|
2018-06-01 14:04:31 +00:00
|
|
|
int so, shift, sib_core;
|
2018-06-02 02:08:58 +00:00
|
|
|
int cpu = thiscpu->logical_cpu_id;
|
|
|
|
int offset = topo.max_cpu_num + 1;
|
|
|
|
size_t size;
|
2018-06-01 14:04:31 +00:00
|
|
|
int thread_id = 0;
|
2018-06-02 02:08:58 +00:00
|
|
|
|
|
|
|
thiscpu->put_ids = CPU_ALLOC((topo.max_cpu_num + 1));
|
2018-06-01 14:04:31 +00:00
|
|
|
if (thiscpu->thread_id < 0)
|
|
|
|
thiscpu->thread_id = thread_id++;
|
2018-06-02 02:08:58 +00:00
|
|
|
if (!thiscpu->put_ids)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
size = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
|
|
|
|
CPU_ZERO_S(size, thiscpu->put_ids);
|
|
|
|
|
|
|
|
sprintf(path,
|
|
|
|
"/sys/devices/system/cpu/cpu%d/topology/thread_siblings", cpu);
|
|
|
|
filep = fopen_or_die(path, "r");
|
|
|
|
do {
|
|
|
|
offset -= BITMASK_SIZE;
|
2019-03-21 03:01:03 +00:00
|
|
|
if (fscanf(filep, "%lx%c", &map, &character) != 2)
|
|
|
|
err(1, "%s: failed to parse file", path);
|
2018-06-02 02:08:58 +00:00
|
|
|
for (shift = 0; shift < BITMASK_SIZE; shift++) {
|
|
|
|
if ((map >> shift) & 0x1) {
|
2018-06-01 14:04:31 +00:00
|
|
|
so = shift + offset;
|
|
|
|
sib_core = get_core_id(so);
|
|
|
|
if (sib_core == thiscpu->physical_core_id) {
|
|
|
|
CPU_SET_S(so, size, thiscpu->put_ids);
|
|
|
|
if ((so != cpu) &&
|
|
|
|
(cpus[so].thread_id < 0))
|
|
|
|
cpus[so].thread_id =
|
|
|
|
thread_id++;
|
|
|
|
}
|
2018-06-02 02:08:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (!strncmp(&character, ",", 1));
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
fclose(filep);
|
2018-06-02 02:08:58 +00:00
|
|
|
|
|
|
|
return CPU_COUNT_S(size, thiscpu->put_ids);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
/*
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
* run func(thread, core, package) in topology order
|
|
|
|
* skip non-present cpus
|
2010-10-23 03:53:03 +00:00
|
|
|
*/
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
int for_all_cpus_2(int (func)(struct thread_data *, struct core_data *,
|
|
|
|
struct pkg_data *, struct thread_data *, struct core_data *,
|
|
|
|
struct pkg_data *), struct thread_data *thread_base,
|
|
|
|
struct core_data *core_base, struct pkg_data *pkg_base,
|
|
|
|
struct thread_data *thread_base2, struct core_data *core_base2,
|
|
|
|
struct pkg_data *pkg_base2)
|
|
|
|
{
|
2018-06-01 14:04:34 +00:00
|
|
|
int retval, pkg_no, node_no, core_no, thread_no;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
|
2018-06-01 14:04:34 +00:00
|
|
|
for (node_no = 0; node_no < topo.nodes_per_pkg; ++node_no) {
|
|
|
|
for (core_no = 0; core_no < topo.cores_per_node;
|
|
|
|
++core_no) {
|
|
|
|
for (thread_no = 0; thread_no <
|
|
|
|
topo.threads_per_core; ++thread_no) {
|
|
|
|
struct thread_data *t, *t2;
|
|
|
|
struct core_data *c, *c2;
|
|
|
|
struct pkg_data *p, *p2;
|
|
|
|
|
|
|
|
t = GET_THREAD(thread_base, thread_no,
|
|
|
|
core_no, node_no,
|
|
|
|
pkg_no);
|
|
|
|
|
|
|
|
if (cpu_is_not_present(t->cpu_id))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
t2 = GET_THREAD(thread_base2, thread_no,
|
|
|
|
core_no, node_no,
|
|
|
|
pkg_no);
|
|
|
|
|
|
|
|
c = GET_CORE(core_base, core_no,
|
|
|
|
node_no, pkg_no);
|
|
|
|
c2 = GET_CORE(core_base2, core_no,
|
|
|
|
node_no,
|
|
|
|
pkg_no);
|
|
|
|
|
|
|
|
p = GET_PKG(pkg_base, pkg_no);
|
|
|
|
p2 = GET_PKG(pkg_base2, pkg_no);
|
|
|
|
|
|
|
|
retval = func(t, c, p, t2, c2, p2);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* run func(cpu) on every cpu in /proc/stat
|
|
|
|
* return max_cpu number
|
|
|
|
*/
|
|
|
|
int for_all_proc_cpus(int (func)(int))
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
|
|
|
FILE *fp;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
int cpu_num;
|
2010-10-23 03:53:03 +00:00
|
|
|
int retval;
|
|
|
|
|
2013-08-21 00:20:17 +00:00
|
|
|
fp = fopen_or_die(proc_stat, "r");
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
retval = fscanf(fp, "cpu %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n");
|
2013-08-21 00:20:18 +00:00
|
|
|
if (retval != 0)
|
|
|
|
err(1, "%s: failed to parse format", proc_stat);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
while (1) {
|
|
|
|
retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu_num);
|
2010-10-23 03:53:03 +00:00
|
|
|
if (retval != 1)
|
|
|
|
break;
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
retval = func(cpu_num);
|
|
|
|
if (retval) {
|
|
|
|
fclose(fp);
|
|
|
|
return(retval);
|
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
fclose(fp);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void re_initialize(void)
|
|
|
|
{
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
free_all_buffers();
|
|
|
|
setup_all_buffers();
|
|
|
|
printf("turbostat: re-initialized with num_cpus %d\n", topo.num_cpus);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2018-06-01 14:04:28 +00:00
|
|
|
void set_max_cpu_num(void)
|
|
|
|
{
|
|
|
|
FILE *filep;
|
|
|
|
unsigned long dummy;
|
|
|
|
|
|
|
|
topo.max_cpu_num = 0;
|
|
|
|
filep = fopen_or_die(
|
|
|
|
"/sys/devices/system/cpu/cpu0/topology/thread_siblings",
|
|
|
|
"r");
|
|
|
|
while (fscanf(filep, "%lx,", &dummy) == 1)
|
2018-06-02 02:08:58 +00:00
|
|
|
topo.max_cpu_num += BITMASK_SIZE;
|
2018-06-01 14:04:28 +00:00
|
|
|
fclose(filep);
|
|
|
|
topo.max_cpu_num--; /* 0 based */
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
/*
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
* count_cpus()
|
|
|
|
* remember the last one seen, it will be the max
|
2010-10-23 03:53:03 +00:00
|
|
|
*/
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
int count_cpus(int cpu)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2018-06-01 14:04:28 +00:00
|
|
|
topo.num_cpus++;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int mark_cpu_present(int cpu)
|
|
|
|
{
|
|
|
|
CPU_SET_S(cpu, cpu_present_setsize, cpu_present_set);
|
2012-03-30 02:19:58 +00:00
|
|
|
return 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2018-06-01 14:04:31 +00:00
|
|
|
int init_thread_id(int cpu)
|
|
|
|
{
|
|
|
|
cpus[cpu].thread_id = -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-27 04:48:05 +00:00
|
|
|
/*
|
|
|
|
* snapshot_proc_interrupts()
|
|
|
|
*
|
|
|
|
* read and record summary of /proc/interrupts
|
|
|
|
*
|
|
|
|
* return 1 if config change requires a restart, else return 0
|
|
|
|
*/
|
|
|
|
int snapshot_proc_interrupts(void)
|
|
|
|
{
|
|
|
|
static FILE *fp;
|
|
|
|
int column, retval;
|
|
|
|
|
|
|
|
if (fp == NULL)
|
|
|
|
fp = fopen_or_die("/proc/interrupts", "r");
|
|
|
|
else
|
|
|
|
rewind(fp);
|
|
|
|
|
|
|
|
/* read 1st line of /proc/interrupts to get cpu* name for each column */
|
|
|
|
for (column = 0; column < topo.num_cpus; ++column) {
|
|
|
|
int cpu_number;
|
|
|
|
|
|
|
|
retval = fscanf(fp, " CPU%d", &cpu_number);
|
|
|
|
if (retval != 1)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (cpu_number > topo.max_cpu_num) {
|
|
|
|
warn("/proc/interrupts: cpu%d: > %d", cpu_number, topo.max_cpu_num);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
irq_column_2_cpu[column] = cpu_number;
|
|
|
|
irqs_per_cpu[cpu_number] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* read /proc/interrupt count lines and sum up irqs per cpu */
|
|
|
|
while (1) {
|
|
|
|
int column;
|
|
|
|
char buf[64];
|
|
|
|
|
|
|
|
retval = fscanf(fp, " %s:", buf); /* flush irq# "N:" */
|
|
|
|
if (retval != 1)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* read the count per cpu */
|
|
|
|
for (column = 0; column < topo.num_cpus; ++column) {
|
|
|
|
|
|
|
|
int cpu_number, irq_count;
|
|
|
|
|
|
|
|
retval = fscanf(fp, " %d", &irq_count);
|
|
|
|
if (retval != 1)
|
|
|
|
break;
|
|
|
|
|
|
|
|
cpu_number = irq_column_2_cpu[column];
|
|
|
|
irqs_per_cpu[cpu_number] += irq_count;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
while (getc(fp) != '\n')
|
|
|
|
; /* flush interrupt description */
|
|
|
|
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-27 06:28:12 +00:00
|
|
|
/*
|
|
|
|
* snapshot_gfx_rc6_ms()
|
|
|
|
*
|
|
|
|
* record snapshot of
|
|
|
|
* /sys/class/drm/card0/power/rc6_residency_ms
|
|
|
|
*
|
|
|
|
* return 1 if config change requires a restart, else return 0
|
|
|
|
*/
|
|
|
|
int snapshot_gfx_rc6_ms(void)
|
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
fp = fopen_or_die("/sys/class/drm/card0/power/rc6_residency_ms", "r");
|
|
|
|
|
|
|
|
retval = fscanf(fp, "%lld", &gfx_cur_rc6_ms);
|
|
|
|
if (retval != 1)
|
|
|
|
err(1, "GFX rc6");
|
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-27 05:37:54 +00:00
|
|
|
/*
|
|
|
|
* snapshot_gfx_mhz()
|
|
|
|
*
|
|
|
|
* record snapshot of
|
|
|
|
* /sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz
|
|
|
|
*
|
|
|
|
* return 1 if config change requires a restart, else return 0
|
|
|
|
*/
|
|
|
|
int snapshot_gfx_mhz(void)
|
|
|
|
{
|
|
|
|
static FILE *fp;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
if (fp == NULL)
|
|
|
|
fp = fopen_or_die("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", "r");
|
2017-03-04 20:42:48 +00:00
|
|
|
else {
|
2016-02-27 05:37:54 +00:00
|
|
|
rewind(fp);
|
2017-03-04 20:42:48 +00:00
|
|
|
fflush(fp);
|
|
|
|
}
|
2016-02-27 05:37:54 +00:00
|
|
|
|
|
|
|
retval = fscanf(fp, "%d", &gfx_cur_mhz);
|
|
|
|
if (retval != 1)
|
|
|
|
err(1, "GFX MHz");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-27 04:48:05 +00:00
|
|
|
|
2018-06-01 16:35:53 +00:00
|
|
|
/*
|
|
|
|
* snapshot_cpu_lpi()
|
|
|
|
*
|
|
|
|
* record snapshot of
|
|
|
|
* /sys/devices/system/cpu/cpuidle/low_power_idle_cpu_residency_us
|
|
|
|
*
|
|
|
|
* return 1 if config change requires a restart, else return 0
|
|
|
|
*/
|
|
|
|
int snapshot_cpu_lpi_us(void)
|
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
fp = fopen_or_die("/sys/devices/system/cpu/cpuidle/low_power_idle_cpu_residency_us", "r");
|
|
|
|
|
|
|
|
retval = fscanf(fp, "%lld", &cpuidle_cur_cpu_lpi_us);
|
2018-09-25 12:59:26 +00:00
|
|
|
if (retval != 1) {
|
|
|
|
fprintf(stderr, "Disabling Low Power Idle CPU output\n");
|
|
|
|
BIC_NOT_PRESENT(BIC_CPU_LPI);
|
|
|
|
return -1;
|
|
|
|
}
|
2018-06-01 16:35:53 +00:00
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* snapshot_sys_lpi()
|
|
|
|
*
|
|
|
|
* record snapshot of
|
|
|
|
* /sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us
|
|
|
|
*
|
|
|
|
* return 1 if config change requires a restart, else return 0
|
|
|
|
*/
|
|
|
|
int snapshot_sys_lpi_us(void)
|
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
fp = fopen_or_die("/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us", "r");
|
|
|
|
|
|
|
|
retval = fscanf(fp, "%lld", &cpuidle_cur_sys_lpi_us);
|
2018-09-25 12:59:26 +00:00
|
|
|
if (retval != 1) {
|
|
|
|
fprintf(stderr, "Disabling Low Power Idle System output\n");
|
|
|
|
BIC_NOT_PRESENT(BIC_SYS_LPI);
|
2019-04-08 09:00:44 +00:00
|
|
|
fclose(fp);
|
2018-09-25 12:59:26 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2018-06-01 16:35:53 +00:00
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-27 04:48:05 +00:00
|
|
|
/*
|
|
|
|
* snapshot /proc and /sys files
|
|
|
|
*
|
|
|
|
* return 1 if configuration restart needed, else return 0
|
|
|
|
*/
|
|
|
|
int snapshot_proc_sysfs_files(void)
|
|
|
|
{
|
2017-02-15 03:07:52 +00:00
|
|
|
if (DO_BIC(BIC_IRQ))
|
|
|
|
if (snapshot_proc_interrupts())
|
|
|
|
return 1;
|
2016-02-27 04:48:05 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFX_rc6))
|
2016-02-27 06:28:12 +00:00
|
|
|
snapshot_gfx_rc6_ms();
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (DO_BIC(BIC_GFXMHz))
|
2016-02-27 05:37:54 +00:00
|
|
|
snapshot_gfx_mhz();
|
|
|
|
|
2018-06-01 16:35:53 +00:00
|
|
|
if (DO_BIC(BIC_CPU_LPI))
|
|
|
|
snapshot_cpu_lpi_us();
|
|
|
|
|
|
|
|
if (DO_BIC(BIC_SYS_LPI))
|
|
|
|
snapshot_sys_lpi_us();
|
|
|
|
|
2016-02-27 04:48:05 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-15 18:57:37 +00:00
|
|
|
int exit_requested;
|
|
|
|
|
|
|
|
static void signal_handler (int signal)
|
|
|
|
{
|
|
|
|
switch (signal) {
|
|
|
|
case SIGINT:
|
|
|
|
exit_requested = 1;
|
|
|
|
if (debug)
|
|
|
|
fprintf(stderr, " SIGINT\n");
|
|
|
|
break;
|
2017-07-15 19:51:26 +00:00
|
|
|
case SIGUSR1:
|
|
|
|
if (debug > 1)
|
|
|
|
fprintf(stderr, "SIGUSR1\n");
|
|
|
|
break;
|
2017-07-15 18:57:37 +00:00
|
|
|
}
|
2017-07-19 23:28:37 +00:00
|
|
|
/* make sure this manually-invoked interval is at least 1ms long */
|
|
|
|
nanosleep(&one_msec, NULL);
|
2017-07-15 18:57:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void setup_signal_handler(void)
|
|
|
|
{
|
|
|
|
struct sigaction sa;
|
|
|
|
|
|
|
|
memset(&sa, 0, sizeof(sa));
|
|
|
|
|
|
|
|
sa.sa_handler = &signal_handler;
|
|
|
|
|
|
|
|
if (sigaction(SIGINT, &sa, NULL) < 0)
|
|
|
|
err(1, "sigaction SIGINT");
|
2017-07-15 19:51:26 +00:00
|
|
|
if (sigaction(SIGUSR1, &sa, NULL) < 0)
|
|
|
|
err(1, "sigaction SIGUSR1");
|
2017-07-15 18:57:37 +00:00
|
|
|
}
|
2017-07-19 23:28:37 +00:00
|
|
|
|
2017-10-04 12:01:47 +00:00
|
|
|
void do_sleep(void)
|
2017-07-19 23:28:37 +00:00
|
|
|
{
|
|
|
|
struct timeval select_timeout;
|
|
|
|
fd_set readfds;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
FD_ZERO(&readfds);
|
|
|
|
FD_SET(0, &readfds);
|
|
|
|
|
2017-10-04 12:01:47 +00:00
|
|
|
if (!isatty(fileno(stdin))) {
|
|
|
|
nanosleep(&interval_ts, NULL);
|
|
|
|
return;
|
|
|
|
}
|
2017-07-19 23:28:37 +00:00
|
|
|
|
2017-10-04 12:01:47 +00:00
|
|
|
select_timeout = interval_tv;
|
2017-07-19 23:28:37 +00:00
|
|
|
retval = select(1, &readfds, NULL, NULL, &select_timeout);
|
|
|
|
|
|
|
|
if (retval == 1) {
|
|
|
|
switch (getc(stdin)) {
|
|
|
|
case 'q':
|
|
|
|
exit_requested = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* make sure this manually-invoked interval is at least 1ms long */
|
|
|
|
nanosleep(&one_msec, NULL);
|
|
|
|
}
|
|
|
|
}
|
2017-10-04 12:01:47 +00:00
|
|
|
|
2018-06-06 21:44:48 +00:00
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
void turbostat_loop()
|
|
|
|
{
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
int retval;
|
2012-11-09 03:38:05 +00:00
|
|
|
int restarted = 0;
|
2018-04-26 00:41:03 +00:00
|
|
|
int done_iters = 0;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2017-07-15 18:57:37 +00:00
|
|
|
setup_signal_handler();
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
restart:
|
2012-11-09 03:38:05 +00:00
|
|
|
restarted++;
|
|
|
|
|
2016-02-27 04:48:05 +00:00
|
|
|
snapshot_proc_sysfs_files();
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
retval = for_all_cpus(get_counters, EVEN_COUNTERS);
|
2018-06-06 21:44:48 +00:00
|
|
|
first_counter_read = 0;
|
2012-11-01 04:08:19 +00:00
|
|
|
if (retval < -1) {
|
|
|
|
exit(retval);
|
|
|
|
} else if (retval == -1) {
|
2012-11-09 03:38:05 +00:00
|
|
|
if (restarted > 1) {
|
|
|
|
exit(retval);
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
re_initialize();
|
|
|
|
goto restart;
|
|
|
|
}
|
2012-11-09 03:38:05 +00:00
|
|
|
restarted = 0;
|
2018-04-26 00:41:03 +00:00
|
|
|
done_iters = 0;
|
2010-10-23 03:53:03 +00:00
|
|
|
gettimeofday(&tv_even, (struct timezone *)NULL);
|
|
|
|
|
|
|
|
while (1) {
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (for_all_proc_cpus(cpu_is_not_present)) {
|
2010-10-23 03:53:03 +00:00
|
|
|
re_initialize();
|
|
|
|
goto restart;
|
|
|
|
}
|
2017-07-19 23:28:37 +00:00
|
|
|
do_sleep();
|
2016-02-27 04:48:05 +00:00
|
|
|
if (snapshot_proc_sysfs_files())
|
|
|
|
goto restart;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
retval = for_all_cpus(get_counters, ODD_COUNTERS);
|
2012-11-01 04:08:19 +00:00
|
|
|
if (retval < -1) {
|
|
|
|
exit(retval);
|
|
|
|
} else if (retval == -1) {
|
2012-03-30 02:19:58 +00:00
|
|
|
re_initialize();
|
|
|
|
goto restart;
|
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
gettimeofday(&tv_odd, (struct timezone *)NULL);
|
|
|
|
timersub(&tv_odd, &tv_even, &tv_delta);
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
if (for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS)) {
|
|
|
|
re_initialize();
|
|
|
|
goto restart;
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
compute_average(EVEN_COUNTERS);
|
|
|
|
format_all_counters(EVEN_COUNTERS);
|
2016-02-14 04:36:17 +00:00
|
|
|
flush_output_stdout();
|
2017-07-15 18:57:37 +00:00
|
|
|
if (exit_requested)
|
|
|
|
break;
|
2018-04-26 00:41:03 +00:00
|
|
|
if (num_iterations && ++done_iters >= num_iterations)
|
|
|
|
break;
|
2017-07-19 23:28:37 +00:00
|
|
|
do_sleep();
|
2016-02-27 04:48:05 +00:00
|
|
|
if (snapshot_proc_sysfs_files())
|
|
|
|
goto restart;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
retval = for_all_cpus(get_counters, EVEN_COUNTERS);
|
2012-11-01 04:08:19 +00:00
|
|
|
if (retval < -1) {
|
|
|
|
exit(retval);
|
|
|
|
} else if (retval == -1) {
|
2010-10-23 03:53:03 +00:00
|
|
|
re_initialize();
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
gettimeofday(&tv_even, (struct timezone *)NULL);
|
|
|
|
timersub(&tv_even, &tv_odd, &tv_delta);
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
if (for_all_cpus_2(delta_cpu, EVEN_COUNTERS, ODD_COUNTERS)) {
|
|
|
|
re_initialize();
|
|
|
|
goto restart;
|
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
compute_average(ODD_COUNTERS);
|
|
|
|
format_all_counters(ODD_COUNTERS);
|
2016-02-14 04:36:17 +00:00
|
|
|
flush_output_stdout();
|
2017-07-15 18:57:37 +00:00
|
|
|
if (exit_requested)
|
|
|
|
break;
|
2018-04-26 00:41:03 +00:00
|
|
|
if (num_iterations && ++done_iters >= num_iterations)
|
|
|
|
break;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void check_dev_msr()
|
|
|
|
{
|
|
|
|
struct stat sb;
|
2015-05-25 12:34:28 +00:00
|
|
|
char pathname[32];
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-05-25 12:34:28 +00:00
|
|
|
sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
|
|
|
|
if (stat(pathname, &sb))
|
2015-03-24 20:37:35 +00:00
|
|
|
if (system("/sbin/modprobe msr > /dev/null 2>&1"))
|
|
|
|
err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2014-08-15 04:36:50 +00:00
|
|
|
void check_permissions()
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2014-08-15 04:36:50 +00:00
|
|
|
struct __user_cap_header_struct cap_header_data;
|
|
|
|
cap_user_header_t cap_header = &cap_header_data;
|
|
|
|
struct __user_cap_data_struct cap_data_data;
|
|
|
|
cap_user_data_t cap_data = &cap_data_data;
|
|
|
|
extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
|
|
|
|
int do_exit = 0;
|
2015-05-25 12:34:28 +00:00
|
|
|
char pathname[32];
|
2014-08-15 04:36:50 +00:00
|
|
|
|
|
|
|
/* check for CAP_SYS_RAWIO */
|
|
|
|
cap_header->pid = getpid();
|
|
|
|
cap_header->version = _LINUX_CAPABILITY_VERSION;
|
|
|
|
if (capget(cap_header, cap_data) < 0)
|
|
|
|
err(-6, "capget(2) failed");
|
|
|
|
|
|
|
|
if ((cap_data->effective & (1 << CAP_SYS_RAWIO)) == 0) {
|
|
|
|
do_exit++;
|
|
|
|
warnx("capget(CAP_SYS_RAWIO) failed,"
|
|
|
|
" try \"# setcap cap_sys_rawio=ep %s\"", progname);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* test file permissions */
|
2015-05-25 12:34:28 +00:00
|
|
|
sprintf(pathname, "/dev/cpu/%d/msr", base_cpu);
|
|
|
|
if (euidaccess(pathname, R_OK)) {
|
2014-08-15 04:36:50 +00:00
|
|
|
do_exit++;
|
|
|
|
warn("/dev/cpu/0/msr open failed, try chown or chmod +r /dev/cpu/*/msr");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if all else fails, thell them to be root */
|
|
|
|
if (do_exit)
|
|
|
|
if (getuid() != 0)
|
2015-01-23 05:12:33 +00:00
|
|
|
warnx("... or simply run as root");
|
2014-08-15 04:36:50 +00:00
|
|
|
|
|
|
|
if (do_exit)
|
|
|
|
exit(-6);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
/*
|
|
|
|
* NHM adds support for additional MSRs:
|
|
|
|
*
|
|
|
|
* MSR_SMI_COUNT 0x00000034
|
|
|
|
*
|
2015-11-12 07:42:31 +00:00
|
|
|
* MSR_PLATFORM_INFO 0x000000ce
|
2017-01-08 04:24:57 +00:00
|
|
|
* MSR_PKG_CST_CONFIG_CONTROL 0x000000e2
|
2015-01-23 05:12:33 +00:00
|
|
|
*
|
2017-01-01 18:08:33 +00:00
|
|
|
* MSR_MISC_PWR_MGMT 0x000001aa
|
|
|
|
*
|
2015-01-23 05:12:33 +00:00
|
|
|
* MSR_PKG_C3_RESIDENCY 0x000003f8
|
|
|
|
* MSR_PKG_C6_RESIDENCY 0x000003f9
|
|
|
|
* MSR_CORE_C3_RESIDENCY 0x000003fc
|
|
|
|
* MSR_CORE_C6_RESIDENCY 0x000003fd
|
|
|
|
*
|
2015-02-10 04:39:45 +00:00
|
|
|
* Side effect:
|
2017-01-08 04:24:57 +00:00
|
|
|
* sets global pkg_cstate_limit to decode MSR_PKG_CST_CONFIG_CONTROL
|
2017-01-21 06:26:16 +00:00
|
|
|
* sets has_misc_feature_control
|
2015-01-23 05:12:33 +00:00
|
|
|
*/
|
2015-02-10 04:39:45 +00:00
|
|
|
int probe_nhm_msrs(unsigned int family, unsigned int model)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2015-02-10 04:39:45 +00:00
|
|
|
unsigned long long msr;
|
2015-10-20 02:37:40 +00:00
|
|
|
unsigned int base_ratio;
|
2015-02-10 04:39:45 +00:00
|
|
|
int *pkg_cstate_limits;
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
return 0;
|
|
|
|
|
2015-10-20 02:37:40 +00:00
|
|
|
bclk = discover_bclk(family, model);
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_NEHALEM: /* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */
|
|
|
|
case INTEL_FAM6_NEHALEM_EX: /* Nehalem-EX Xeon - Beckton */
|
2015-02-10 04:39:45 +00:00
|
|
|
pkg_cstate_limits = nhm_pkg_cstate_limits;
|
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SANDYBRIDGE: /* SNB */
|
|
|
|
case INTEL_FAM6_SANDYBRIDGE_X: /* SNB Xeon */
|
|
|
|
case INTEL_FAM6_IVYBRIDGE: /* IVB */
|
|
|
|
case INTEL_FAM6_IVYBRIDGE_X: /* IVB Xeon */
|
2015-02-10 04:39:45 +00:00
|
|
|
pkg_cstate_limits = snb_pkg_cstate_limits;
|
2017-01-21 06:26:16 +00:00
|
|
|
has_misc_feature_control = 1;
|
2015-02-10 04:39:45 +00:00
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_HASWELL_CORE: /* HSW */
|
|
|
|
case INTEL_FAM6_HASWELL_X: /* HSX */
|
|
|
|
case INTEL_FAM6_HASWELL_GT3E: /* HSW */
|
|
|
|
case INTEL_FAM6_BROADWELL_CORE: /* BDW */
|
|
|
|
case INTEL_FAM6_BROADWELL_GT3E: /* BDW */
|
|
|
|
case INTEL_FAM6_BROADWELL_X: /* BDX */
|
|
|
|
case INTEL_FAM6_SKYLAKE_MOBILE: /* SKL */
|
2018-05-31 17:39:07 +00:00
|
|
|
case INTEL_FAM6_CANNONLAKE_MOBILE: /* CNL */
|
2015-02-10 04:39:45 +00:00
|
|
|
pkg_cstate_limits = hsw_pkg_cstate_limits;
|
2017-01-21 06:26:16 +00:00
|
|
|
has_misc_feature_control = 1;
|
2015-02-10 04:39:45 +00:00
|
|
|
break;
|
2016-12-02 01:27:46 +00:00
|
|
|
case INTEL_FAM6_SKYLAKE_X: /* SKX */
|
|
|
|
pkg_cstate_limits = skx_pkg_cstate_limits;
|
2017-01-21 06:26:16 +00:00
|
|
|
has_misc_feature_control = 1;
|
2016-12-02 01:27:46 +00:00
|
|
|
break;
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT: /* BYT */
|
2017-01-01 18:08:33 +00:00
|
|
|
no_MSR_MISC_PWR_MGMT = 1;
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT_X: /* AVN */
|
2015-02-10 04:39:45 +00:00
|
|
|
pkg_cstate_limits = slv_pkg_cstate_limits;
|
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_ATOM_AIRMONT: /* AMT */
|
2015-02-10 04:39:45 +00:00
|
|
|
pkg_cstate_limits = amt_pkg_cstate_limits;
|
2017-01-01 18:08:33 +00:00
|
|
|
no_MSR_MISC_PWR_MGMT = 1;
|
2015-02-10 04:39:45 +00:00
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_XEON_PHI_KNL: /* PHI */
|
2015-02-10 04:39:45 +00:00
|
|
|
pkg_cstate_limits = phi_pkg_cstate_limits;
|
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT: /* BXT */
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
|
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_X: /* DNV */
|
2018-12-15 01:02:27 +00:00
|
|
|
pkg_cstate_limits = glm_pkg_cstate_limits;
|
2016-04-06 21:15:56 +00:00
|
|
|
break;
|
2010-10-23 03:53:03 +00:00
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-08 04:24:57 +00:00
|
|
|
get_msr(base_cpu, MSR_PKG_CST_CONFIG_CONTROL, &msr);
|
2015-04-02 01:02:57 +00:00
|
|
|
pkg_cstate_limit = pkg_cstate_limits[msr & 0xF];
|
2015-02-10 04:39:45 +00:00
|
|
|
|
2015-11-12 07:42:31 +00:00
|
|
|
get_msr(base_cpu, MSR_PLATFORM_INFO, &msr);
|
2015-10-20 02:37:40 +00:00
|
|
|
base_ratio = (msr >> 8) & 0xFF;
|
|
|
|
|
|
|
|
base_hz = base_ratio * bclk * 1000000;
|
|
|
|
has_base_hz = 1;
|
2015-02-10 04:39:45 +00:00
|
|
|
return 1;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
2017-01-13 04:49:18 +00:00
|
|
|
/*
|
2017-02-08 07:41:51 +00:00
|
|
|
* SLV client has support for unique MSRs:
|
2017-01-13 04:49:18 +00:00
|
|
|
*
|
|
|
|
* MSR_CC6_DEMOTION_POLICY_CONFIG
|
|
|
|
* MSR_MC6_DEMOTION_POLICY_CONFIG
|
|
|
|
*/
|
|
|
|
|
|
|
|
int has_slv_msrs(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT:
|
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT_MID:
|
|
|
|
case INTEL_FAM6_ATOM_AIRMONT_MID:
|
2017-01-13 04:49:18 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
tools/power turbostat: Denverton: use HW CC1 counter, skip C3, C7
The CC1 column in tubostat can be computed by subtracting
the core c-state residency countes from the total Cx residency.
CC1 = (Idle_time_as_measured by MPERF) - (all core C-states with
residency counters)
However, as the underlying counter reads are not atomic,
error can be noticed in this calculations, especially
when the numbers are small.
Denverton has a hardware CC1 residency counter
to improve the accuracy of the cc1 statistic -- use it.
At the same time, Denverton has no concept of CC3, PC3, CC7, PC7,
so skip collecting and printing those columns.
Finally, a note of clarification.
Turbostat prints the standard PC2 residency counter,
but on Denverton hardware, that actually means PC1E.
Turbostat prints the standard PC6 residency counter,
but on Denverton hardware, that actually means PC2.
At this point, we document that differnce in this commit message,
rather than adding a quirk to the software.
Signed-off-by: Len Brown <len.brown@intel.com>
2017-01-27 07:13:27 +00:00
|
|
|
int is_dnv(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_X:
|
tools/power turbostat: Denverton: use HW CC1 counter, skip C3, C7
The CC1 column in tubostat can be computed by subtracting
the core c-state residency countes from the total Cx residency.
CC1 = (Idle_time_as_measured by MPERF) - (all core C-states with
residency counters)
However, as the underlying counter reads are not atomic,
error can be noticed in this calculations, especially
when the numbers are small.
Denverton has a hardware CC1 residency counter
to improve the accuracy of the cc1 statistic -- use it.
At the same time, Denverton has no concept of CC3, PC3, CC7, PC7,
so skip collecting and printing those columns.
Finally, a note of clarification.
Turbostat prints the standard PC2 residency counter,
but on Denverton hardware, that actually means PC1E.
Turbostat prints the standard PC6 residency counter,
but on Denverton hardware, that actually means PC2.
At this point, we document that differnce in this commit message,
rather than adding a quirk to the software.
Signed-off-by: Len Brown <len.brown@intel.com>
2017-01-27 07:13:27 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2017-02-10 06:56:47 +00:00
|
|
|
int is_bdx(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
case INTEL_FAM6_BROADWELL_X:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-27 07:36:41 +00:00
|
|
|
int is_skx(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
case INTEL_FAM6_SKYLAKE_X:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2017-01-13 04:49:18 +00:00
|
|
|
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
int has_turbo_ratio_limit(unsigned int family, unsigned int model)
|
2015-01-23 05:12:33 +00:00
|
|
|
{
|
2017-01-13 04:49:18 +00:00
|
|
|
if (has_slv_msrs(family, model))
|
|
|
|
return 0;
|
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
switch (model) {
|
|
|
|
/* Nehalem compatible, but do not include turbo-ratio limit support */
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_NEHALEM_EX: /* Nehalem-EX Xeon - Beckton */
|
|
|
|
case INTEL_FAM6_XEON_PHI_KNL: /* PHI - Knights Landing (different MSR definition) */
|
2015-01-23 05:12:33 +00:00
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2017-01-13 04:49:18 +00:00
|
|
|
int has_atom_turbo_ratio_limit(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (has_slv_msrs(family, model))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2012-09-21 04:01:31 +00:00
|
|
|
int has_ivt_turbo_ratio_limit(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_IVYBRIDGE_X: /* IVB Xeon */
|
|
|
|
case INTEL_FAM6_HASWELL_X: /* HSW Xeon */
|
2015-03-24 00:29:09 +00:00
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int has_hsw_turbo_ratio_limit(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_HASWELL_X: /* HSW Xeon */
|
2012-09-21 04:01:31 +00:00
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-20 16:49:34 +00:00
|
|
|
int has_knl_turbo_ratio_limit(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_XEON_PHI_KNL: /* Knights Landing */
|
2015-05-20 16:49:34 +00:00
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
int has_glm_turbo_ratio_limit(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT:
|
|
|
|
case INTEL_FAM6_SKYLAKE_X:
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2015-06-17 20:23:45 +00:00
|
|
|
int has_config_tdp(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_IVYBRIDGE: /* IVB */
|
|
|
|
case INTEL_FAM6_HASWELL_CORE: /* HSW */
|
|
|
|
case INTEL_FAM6_HASWELL_X: /* HSX */
|
|
|
|
case INTEL_FAM6_HASWELL_GT3E: /* HSW */
|
|
|
|
case INTEL_FAM6_BROADWELL_CORE: /* BDW */
|
|
|
|
case INTEL_FAM6_BROADWELL_GT3E: /* BDW */
|
|
|
|
case INTEL_FAM6_BROADWELL_X: /* BDX */
|
|
|
|
case INTEL_FAM6_SKYLAKE_MOBILE: /* SKL */
|
2018-05-31 17:39:07 +00:00
|
|
|
case INTEL_FAM6_CANNONLAKE_MOBILE: /* CNL */
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SKYLAKE_X: /* SKX */
|
|
|
|
|
|
|
|
case INTEL_FAM6_XEON_PHI_KNL: /* Knights Landing */
|
2015-06-17 20:23:45 +00:00
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-24 00:29:09 +00:00
|
|
|
static void
|
2016-03-02 13:50:25 +00:00
|
|
|
dump_cstate_pstate_config_info(unsigned int family, unsigned int model)
|
2015-03-24 00:29:09 +00:00
|
|
|
{
|
|
|
|
if (!do_nhm_platform_info)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dump_nhm_platform_info();
|
|
|
|
|
|
|
|
if (has_hsw_turbo_ratio_limit(family, model))
|
|
|
|
dump_hsw_turbo_ratio_limits();
|
|
|
|
|
|
|
|
if (has_ivt_turbo_ratio_limit(family, model))
|
|
|
|
dump_ivt_turbo_ratio_limits();
|
|
|
|
|
tools/power turbostat: fix decoding for GLM, DNV, SKX turbo-ratio limits
Newer processors do not hard-code the the number of cpus in each bin
to {1, 2, 3, 4, 5, 6, 7, 8} Rather, they can specify any number
of CPUS in each of the 8 bins:
eg.
...
37 * 100.0 = 3600.0 MHz max turbo 4 active cores
38 * 100.0 = 3700.0 MHz max turbo 3 active cores
39 * 100.0 = 3800.0 MHz max turbo 2 active cores
39 * 100.0 = 3900.0 MHz max turbo 1 active cores
could now look something like this:
...
37 * 100.0 = 3600.0 MHz max turbo 16 active cores
38 * 100.0 = 3700.0 MHz max turbo 8 active cores
39 * 100.0 = 3800.0 MHz max turbo 4 active cores
39 * 100.0 = 3900.0 MHz max turbo 2 active cores
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-01 04:07:49 +00:00
|
|
|
if (has_turbo_ratio_limit(family, model))
|
|
|
|
dump_turbo_ratio_limits(family, model);
|
2015-03-24 00:29:09 +00:00
|
|
|
|
2017-01-13 04:49:18 +00:00
|
|
|
if (has_atom_turbo_ratio_limit(family, model))
|
|
|
|
dump_atom_turbo_ratio_limits();
|
|
|
|
|
2015-05-20 16:49:34 +00:00
|
|
|
if (has_knl_turbo_ratio_limit(family, model))
|
|
|
|
dump_knl_turbo_ratio_limits();
|
|
|
|
|
2015-06-17 20:23:45 +00:00
|
|
|
if (has_config_tdp(family, model))
|
|
|
|
dump_config_tdp();
|
|
|
|
|
2015-03-24 00:29:09 +00:00
|
|
|
dump_nhm_cst_cfg();
|
|
|
|
}
|
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
static void
|
|
|
|
dump_sysfs_cstate_config(void)
|
|
|
|
{
|
|
|
|
char path[64];
|
|
|
|
char name_buf[16];
|
|
|
|
char desc[64];
|
|
|
|
FILE *input;
|
|
|
|
int state;
|
|
|
|
char *sp;
|
|
|
|
|
|
|
|
if (!DO_BIC(BIC_sysfs))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (state = 0; state < 10; ++state) {
|
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/cpuidle/state%d/name",
|
|
|
|
base_cpu, state);
|
|
|
|
input = fopen(path, "r");
|
|
|
|
if (input == NULL)
|
|
|
|
continue;
|
2019-03-21 03:01:03 +00:00
|
|
|
if (!fgets(name_buf, sizeof(name_buf), input))
|
|
|
|
err(1, "%s: failed to read file", path);
|
2017-02-09 23:25:22 +00:00
|
|
|
|
|
|
|
/* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */
|
|
|
|
sp = strchr(name_buf, '-');
|
|
|
|
if (!sp)
|
|
|
|
sp = strchrnul(name_buf, '\n');
|
|
|
|
*sp = '\0';
|
|
|
|
fclose(input);
|
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/cpuidle/state%d/desc",
|
|
|
|
base_cpu, state);
|
|
|
|
input = fopen(path, "r");
|
|
|
|
if (input == NULL)
|
|
|
|
continue;
|
2019-03-21 03:01:03 +00:00
|
|
|
if (!fgets(desc, sizeof(desc), input))
|
|
|
|
err(1, "%s: failed to read file", path);
|
2017-02-09 23:25:22 +00:00
|
|
|
|
|
|
|
fprintf(outf, "cpu%d: %s: %s", base_cpu, name_buf, desc);
|
|
|
|
fclose(input);
|
|
|
|
}
|
|
|
|
}
|
2017-02-22 05:11:12 +00:00
|
|
|
static void
|
|
|
|
dump_sysfs_pstate_config(void)
|
|
|
|
{
|
|
|
|
char path[64];
|
|
|
|
char driver_buf[64];
|
|
|
|
char governor_buf[64];
|
|
|
|
FILE *input;
|
|
|
|
int turbo;
|
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_driver",
|
|
|
|
base_cpu);
|
|
|
|
input = fopen(path, "r");
|
|
|
|
if (input == NULL) {
|
2018-08-13 12:45:01 +00:00
|
|
|
fprintf(outf, "NSFOD %s\n", path);
|
2017-02-22 05:11:12 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-03-21 03:01:03 +00:00
|
|
|
if (!fgets(driver_buf, sizeof(driver_buf), input))
|
|
|
|
err(1, "%s: failed to read file", path);
|
2017-02-22 05:11:12 +00:00
|
|
|
fclose(input);
|
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/cpufreq/scaling_governor",
|
|
|
|
base_cpu);
|
|
|
|
input = fopen(path, "r");
|
|
|
|
if (input == NULL) {
|
2018-08-13 12:45:01 +00:00
|
|
|
fprintf(outf, "NSFOD %s\n", path);
|
2017-02-22 05:11:12 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-03-21 03:01:03 +00:00
|
|
|
if (!fgets(governor_buf, sizeof(governor_buf), input))
|
|
|
|
err(1, "%s: failed to read file", path);
|
2017-02-22 05:11:12 +00:00
|
|
|
fclose(input);
|
|
|
|
|
|
|
|
fprintf(outf, "cpu%d: cpufreq driver: %s", base_cpu, driver_buf);
|
|
|
|
fprintf(outf, "cpu%d: cpufreq governor: %s", base_cpu, governor_buf);
|
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpufreq/boost");
|
|
|
|
input = fopen(path, "r");
|
|
|
|
if (input != NULL) {
|
2019-03-21 03:01:03 +00:00
|
|
|
if (fscanf(input, "%d", &turbo) != 1)
|
|
|
|
err(1, "%s: failed to parse number from file", path);
|
2017-02-22 05:11:12 +00:00
|
|
|
fprintf(outf, "cpufreq boost: %d\n", turbo);
|
|
|
|
fclose(input);
|
|
|
|
}
|
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/intel_pstate/no_turbo");
|
|
|
|
input = fopen(path, "r");
|
|
|
|
if (input != NULL) {
|
2019-03-21 03:01:03 +00:00
|
|
|
if (fscanf(input, "%d", &turbo) != 1)
|
|
|
|
err(1, "%s: failed to parse number from file", path);
|
2017-02-22 05:11:12 +00:00
|
|
|
fprintf(outf, "cpufreq intel_pstate no_turbo: %d\n", turbo);
|
|
|
|
fclose(input);
|
|
|
|
}
|
|
|
|
}
|
2017-02-09 23:25:22 +00:00
|
|
|
|
2015-03-24 00:29:09 +00:00
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
/*
|
|
|
|
* print_epb()
|
|
|
|
* Decode the ENERGY_PERF_BIAS MSR
|
|
|
|
*/
|
|
|
|
int print_epb(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
char *epb_string;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
if (!has_epb)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu = t->cpu_id;
|
|
|
|
|
|
|
|
/* EPB is per-package */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (cpu_migrate(cpu)) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "Could not migrate to CPU %d\n", cpu);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_ENERGY_PERF_BIAS, &msr))
|
|
|
|
return 0;
|
|
|
|
|
2015-05-26 16:19:37 +00:00
|
|
|
switch (msr & 0xF) {
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
case ENERGY_PERF_BIAS_PERFORMANCE:
|
|
|
|
epb_string = "performance";
|
|
|
|
break;
|
|
|
|
case ENERGY_PERF_BIAS_NORMAL:
|
|
|
|
epb_string = "balanced";
|
|
|
|
break;
|
|
|
|
case ENERGY_PERF_BIAS_POWERSAVE:
|
|
|
|
epb_string = "powersave";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
epb_string = "custom";
|
|
|
|
break;
|
|
|
|
}
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_ENERGY_PERF_BIAS: 0x%08llx (%s)\n", cpu, msr, epb_string);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-12-01 06:36:39 +00:00
|
|
|
/*
|
|
|
|
* print_hwp()
|
|
|
|
* Decode the MSR_HWP_CAPABILITIES
|
|
|
|
*/
|
|
|
|
int print_hwp(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
if (!has_hwp)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu = t->cpu_id;
|
|
|
|
|
|
|
|
/* MSR_HWP_CAPABILITIES is per-package */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (cpu_migrate(cpu)) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "Could not migrate to CPU %d\n", cpu);
|
2015-12-01 06:36:39 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_PM_ENABLE, &msr))
|
|
|
|
return 0;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_PM_ENABLE: 0x%08llx (%sHWP)\n",
|
2015-12-01 06:36:39 +00:00
|
|
|
cpu, msr, (msr & (1 << 0)) ? "" : "No-");
|
|
|
|
|
|
|
|
/* MSR_PM_ENABLE[1] == 1 if HWP is enabled and MSRs visible */
|
|
|
|
if ((msr & (1 << 0)) == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_HWP_CAPABILITIES, &msr))
|
|
|
|
return 0;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_HWP_CAPABILITIES: 0x%08llx "
|
2017-03-04 23:18:28 +00:00
|
|
|
"(high %d guar %d eff %d low %d)\n",
|
2015-12-01 06:36:39 +00:00
|
|
|
cpu, msr,
|
|
|
|
(unsigned int)HWP_HIGHEST_PERF(msr),
|
|
|
|
(unsigned int)HWP_GUARANTEED_PERF(msr),
|
|
|
|
(unsigned int)HWP_MOSTEFFICIENT_PERF(msr),
|
|
|
|
(unsigned int)HWP_LOWEST_PERF(msr));
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_HWP_REQUEST, &msr))
|
|
|
|
return 0;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_HWP_REQUEST: 0x%08llx "
|
2017-03-04 23:18:28 +00:00
|
|
|
"(min %d max %d des %d epp 0x%x window 0x%x pkg 0x%x)\n",
|
2015-12-01 06:36:39 +00:00
|
|
|
cpu, msr,
|
|
|
|
(unsigned int)(((msr) >> 0) & 0xff),
|
|
|
|
(unsigned int)(((msr) >> 8) & 0xff),
|
|
|
|
(unsigned int)(((msr) >> 16) & 0xff),
|
|
|
|
(unsigned int)(((msr) >> 24) & 0xff),
|
|
|
|
(unsigned int)(((msr) >> 32) & 0xff3),
|
|
|
|
(unsigned int)(((msr) >> 42) & 0x1));
|
|
|
|
|
|
|
|
if (has_hwp_pkg) {
|
|
|
|
if (get_msr(cpu, MSR_HWP_REQUEST_PKG, &msr))
|
|
|
|
return 0;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_HWP_REQUEST_PKG: 0x%08llx "
|
2017-03-04 23:18:28 +00:00
|
|
|
"(min %d max %d des %d epp 0x%x window 0x%x)\n",
|
2015-12-01 06:36:39 +00:00
|
|
|
cpu, msr,
|
|
|
|
(unsigned int)(((msr) >> 0) & 0xff),
|
|
|
|
(unsigned int)(((msr) >> 8) & 0xff),
|
|
|
|
(unsigned int)(((msr) >> 16) & 0xff),
|
|
|
|
(unsigned int)(((msr) >> 24) & 0xff),
|
|
|
|
(unsigned int)(((msr) >> 32) & 0xff3));
|
|
|
|
}
|
|
|
|
if (has_hwp_notify) {
|
|
|
|
if (get_msr(cpu, MSR_HWP_INTERRUPT, &msr))
|
|
|
|
return 0;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_HWP_INTERRUPT: 0x%08llx "
|
2015-12-01 06:36:39 +00:00
|
|
|
"(%s_Guaranteed_Perf_Change, %s_Excursion_Min)\n",
|
|
|
|
cpu, msr,
|
|
|
|
((msr) & 0x1) ? "EN" : "Dis",
|
|
|
|
((msr) & 0x2) ? "EN" : "Dis");
|
|
|
|
}
|
|
|
|
if (get_msr(cpu, MSR_HWP_STATUS, &msr))
|
|
|
|
return 0;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_HWP_STATUS: 0x%08llx "
|
2015-12-01 06:36:39 +00:00
|
|
|
"(%sGuaranteed_Perf_Change, %sExcursion_Min)\n",
|
|
|
|
cpu, msr,
|
|
|
|
((msr) & 0x1) ? "" : "No-",
|
|
|
|
((msr) & 0x2) ? "" : "No-");
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-15 06:39:52 +00:00
|
|
|
/*
|
|
|
|
* print_perf_limit()
|
|
|
|
*/
|
|
|
|
int print_perf_limit(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
cpu = t->cpu_id;
|
|
|
|
|
|
|
|
/* per-package */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (cpu_migrate(cpu)) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "Could not migrate to CPU %d\n", cpu);
|
2014-08-15 06:39:52 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (do_core_perf_limit_reasons) {
|
|
|
|
get_msr(cpu, MSR_CORE_PERF_LIMIT_REASONS, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_CORE_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
|
|
|
|
fprintf(outf, " (Active: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)",
|
2015-03-13 20:30:57 +00:00
|
|
|
(msr & 1 << 15) ? "bit15, " : "",
|
2014-08-15 06:39:52 +00:00
|
|
|
(msr & 1 << 14) ? "bit14, " : "",
|
2015-03-13 20:30:57 +00:00
|
|
|
(msr & 1 << 13) ? "Transitions, " : "",
|
|
|
|
(msr & 1 << 12) ? "MultiCoreTurbo, " : "",
|
|
|
|
(msr & 1 << 11) ? "PkgPwrL2, " : "",
|
|
|
|
(msr & 1 << 10) ? "PkgPwrL1, " : "",
|
|
|
|
(msr & 1 << 9) ? "CorePwr, " : "",
|
|
|
|
(msr & 1 << 8) ? "Amps, " : "",
|
|
|
|
(msr & 1 << 6) ? "VR-Therm, " : "",
|
|
|
|
(msr & 1 << 5) ? "Auto-HWP, " : "",
|
|
|
|
(msr & 1 << 4) ? "Graphics, " : "",
|
|
|
|
(msr & 1 << 2) ? "bit2, " : "",
|
|
|
|
(msr & 1 << 1) ? "ThermStatus, " : "",
|
|
|
|
(msr & 1 << 0) ? "PROCHOT, " : "");
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, " (Logged: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
|
2015-03-13 20:30:57 +00:00
|
|
|
(msr & 1 << 31) ? "bit31, " : "",
|
2014-08-15 06:39:52 +00:00
|
|
|
(msr & 1 << 30) ? "bit30, " : "",
|
2015-03-13 20:30:57 +00:00
|
|
|
(msr & 1 << 29) ? "Transitions, " : "",
|
|
|
|
(msr & 1 << 28) ? "MultiCoreTurbo, " : "",
|
|
|
|
(msr & 1 << 27) ? "PkgPwrL2, " : "",
|
|
|
|
(msr & 1 << 26) ? "PkgPwrL1, " : "",
|
|
|
|
(msr & 1 << 25) ? "CorePwr, " : "",
|
|
|
|
(msr & 1 << 24) ? "Amps, " : "",
|
|
|
|
(msr & 1 << 22) ? "VR-Therm, " : "",
|
|
|
|
(msr & 1 << 21) ? "Auto-HWP, " : "",
|
|
|
|
(msr & 1 << 20) ? "Graphics, " : "",
|
|
|
|
(msr & 1 << 18) ? "bit18, " : "",
|
|
|
|
(msr & 1 << 17) ? "ThermStatus, " : "",
|
|
|
|
(msr & 1 << 16) ? "PROCHOT, " : "");
|
2014-08-15 06:39:52 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
if (do_gfx_perf_limit_reasons) {
|
|
|
|
get_msr(cpu, MSR_GFX_PERF_LIMIT_REASONS, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_GFX_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
|
|
|
|
fprintf(outf, " (Active: %s%s%s%s%s%s%s%s)",
|
2014-08-15 06:39:52 +00:00
|
|
|
(msr & 1 << 0) ? "PROCHOT, " : "",
|
|
|
|
(msr & 1 << 1) ? "ThermStatus, " : "",
|
|
|
|
(msr & 1 << 4) ? "Graphics, " : "",
|
|
|
|
(msr & 1 << 6) ? "VR-Therm, " : "",
|
|
|
|
(msr & 1 << 8) ? "Amps, " : "",
|
|
|
|
(msr & 1 << 9) ? "GFXPwr, " : "",
|
|
|
|
(msr & 1 << 10) ? "PkgPwrL1, " : "",
|
|
|
|
(msr & 1 << 11) ? "PkgPwrL2, " : "");
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, " (Logged: %s%s%s%s%s%s%s%s)\n",
|
2014-08-15 06:39:52 +00:00
|
|
|
(msr & 1 << 16) ? "PROCHOT, " : "",
|
|
|
|
(msr & 1 << 17) ? "ThermStatus, " : "",
|
|
|
|
(msr & 1 << 20) ? "Graphics, " : "",
|
|
|
|
(msr & 1 << 22) ? "VR-Therm, " : "",
|
|
|
|
(msr & 1 << 24) ? "Amps, " : "",
|
|
|
|
(msr & 1 << 25) ? "GFXPwr, " : "",
|
|
|
|
(msr & 1 << 26) ? "PkgPwrL1, " : "",
|
|
|
|
(msr & 1 << 27) ? "PkgPwrL2, " : "");
|
|
|
|
}
|
|
|
|
if (do_ring_perf_limit_reasons) {
|
|
|
|
get_msr(cpu, MSR_RING_PERF_LIMIT_REASONS, &msr);
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_RING_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
|
|
|
|
fprintf(outf, " (Active: %s%s%s%s%s%s)",
|
2014-08-15 06:39:52 +00:00
|
|
|
(msr & 1 << 0) ? "PROCHOT, " : "",
|
|
|
|
(msr & 1 << 1) ? "ThermStatus, " : "",
|
|
|
|
(msr & 1 << 6) ? "VR-Therm, " : "",
|
|
|
|
(msr & 1 << 8) ? "Amps, " : "",
|
|
|
|
(msr & 1 << 10) ? "PkgPwrL1, " : "",
|
|
|
|
(msr & 1 << 11) ? "PkgPwrL2, " : "");
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, " (Logged: %s%s%s%s%s%s)\n",
|
2014-08-15 06:39:52 +00:00
|
|
|
(msr & 1 << 16) ? "PROCHOT, " : "",
|
|
|
|
(msr & 1 << 17) ? "ThermStatus, " : "",
|
|
|
|
(msr & 1 << 22) ? "VR-Therm, " : "",
|
|
|
|
(msr & 1 << 24) ? "Amps, " : "",
|
|
|
|
(msr & 1 << 26) ? "PkgPwrL1, " : "",
|
|
|
|
(msr & 1 << 27) ? "PkgPwrL2, " : "");
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
#define RAPL_POWER_GRANULARITY 0x7FFF /* 15 bit power granularity */
|
|
|
|
#define RAPL_TIME_GRANULARITY 0x3F /* 6 bit time granularity */
|
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
double get_tdp_intel(unsigned int model)
|
2013-11-09 05:30:16 +00:00
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
|
|
|
if (do_rapl & RAPL_PKG_POWER_INFO)
|
2015-05-25 12:34:28 +00:00
|
|
|
if (!get_msr(base_cpu, MSR_PKG_POWER_INFO, &msr))
|
2013-11-09 05:30:16 +00:00
|
|
|
return ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
|
|
|
|
|
|
|
|
switch (model) {
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT:
|
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT_X:
|
2013-11-09 05:30:16 +00:00
|
|
|
return 30.0;
|
|
|
|
default:
|
|
|
|
return 135.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
double get_tdp_amd(unsigned int family)
|
|
|
|
{
|
|
|
|
switch (family) {
|
|
|
|
case 0x17:
|
|
|
|
default:
|
|
|
|
/* This is the max stock TDP of HEDT/Server Fam17h chips */
|
|
|
|
return 250.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-05 05:07:00 +00:00
|
|
|
/*
|
|
|
|
* rapl_dram_energy_units_probe()
|
|
|
|
* Energy units are either hard-coded, or come from RAPL Energy Unit MSR.
|
|
|
|
*/
|
|
|
|
static double
|
|
|
|
rapl_dram_energy_units_probe(int model, double rapl_energy_units)
|
|
|
|
{
|
|
|
|
/* only called for genuine_intel, family 6 */
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_HASWELL_X: /* HSX */
|
|
|
|
case INTEL_FAM6_BROADWELL_X: /* BDX */
|
|
|
|
case INTEL_FAM6_XEON_PHI_KNL: /* KNL */
|
2014-12-05 05:07:00 +00:00
|
|
|
return (rapl_dram_energy_units = 15.3 / 1000000);
|
|
|
|
default:
|
|
|
|
return (rapl_energy_units);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
void rapl_probe_intel(unsigned int family, unsigned int model)
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
{
|
|
|
|
unsigned long long msr;
|
2013-11-09 05:30:16 +00:00
|
|
|
unsigned int time_unit;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
double tdp;
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SANDYBRIDGE:
|
|
|
|
case INTEL_FAM6_IVYBRIDGE:
|
|
|
|
case INTEL_FAM6_HASWELL_CORE: /* HSW */
|
|
|
|
case INTEL_FAM6_HASWELL_GT3E: /* HSW */
|
|
|
|
case INTEL_FAM6_BROADWELL_CORE: /* BDW */
|
|
|
|
case INTEL_FAM6_BROADWELL_GT3E: /* BDW */
|
2013-11-09 05:30:16 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_GFX | RAPL_PKG_POWER_INFO;
|
2017-02-10 05:25:41 +00:00
|
|
|
if (rapl_joules) {
|
|
|
|
BIC_PRESENT(BIC_Pkg_J);
|
|
|
|
BIC_PRESENT(BIC_Cor_J);
|
|
|
|
BIC_PRESENT(BIC_GFX_J);
|
|
|
|
} else {
|
|
|
|
BIC_PRESENT(BIC_PkgWatt);
|
|
|
|
BIC_PRESENT(BIC_CorWatt);
|
|
|
|
BIC_PRESENT(BIC_GFXWatt);
|
|
|
|
}
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT: /* BXT */
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
|
2016-04-06 21:15:56 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_PKG_POWER_INFO;
|
2017-02-10 05:25:41 +00:00
|
|
|
if (rapl_joules)
|
|
|
|
BIC_PRESENT(BIC_Pkg_J);
|
|
|
|
else
|
|
|
|
BIC_PRESENT(BIC_PkgWatt);
|
2016-04-06 21:15:56 +00:00
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SKYLAKE_MOBILE: /* SKL */
|
2018-05-31 17:39:07 +00:00
|
|
|
case INTEL_FAM6_CANNONLAKE_MOBILE: /* CNL */
|
2017-03-04 22:23:07 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_GFX | RAPL_PKG_POWER_INFO;
|
2017-02-10 05:25:41 +00:00
|
|
|
BIC_PRESENT(BIC_PKG__);
|
|
|
|
BIC_PRESENT(BIC_RAM__);
|
|
|
|
if (rapl_joules) {
|
|
|
|
BIC_PRESENT(BIC_Pkg_J);
|
|
|
|
BIC_PRESENT(BIC_Cor_J);
|
|
|
|
BIC_PRESENT(BIC_RAM_J);
|
2017-03-04 22:23:07 +00:00
|
|
|
BIC_PRESENT(BIC_GFX_J);
|
2017-02-10 05:25:41 +00:00
|
|
|
} else {
|
|
|
|
BIC_PRESENT(BIC_PkgWatt);
|
|
|
|
BIC_PRESENT(BIC_CorWatt);
|
|
|
|
BIC_PRESENT(BIC_RAMWatt);
|
2017-03-04 22:23:07 +00:00
|
|
|
BIC_PRESENT(BIC_GFXWatt);
|
2017-02-10 05:25:41 +00:00
|
|
|
}
|
2015-03-26 04:50:30 +00:00
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_HASWELL_X: /* HSX */
|
|
|
|
case INTEL_FAM6_BROADWELL_X: /* BDX */
|
|
|
|
case INTEL_FAM6_SKYLAKE_X: /* SKX */
|
|
|
|
case INTEL_FAM6_XEON_PHI_KNL: /* KNL */
|
2015-03-26 04:50:30 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
|
2017-02-10 05:25:41 +00:00
|
|
|
BIC_PRESENT(BIC_PKG__);
|
|
|
|
BIC_PRESENT(BIC_RAM__);
|
|
|
|
if (rapl_joules) {
|
|
|
|
BIC_PRESENT(BIC_Pkg_J);
|
|
|
|
BIC_PRESENT(BIC_RAM_J);
|
|
|
|
} else {
|
|
|
|
BIC_PRESENT(BIC_PkgWatt);
|
|
|
|
BIC_PRESENT(BIC_RAMWatt);
|
|
|
|
}
|
2013-12-03 07:19:19 +00:00
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SANDYBRIDGE_X:
|
|
|
|
case INTEL_FAM6_IVYBRIDGE_X:
|
2015-03-26 04:50:30 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_PKG_PERF_STATUS | RAPL_DRAM_PERF_STATUS | RAPL_PKG_POWER_INFO;
|
2017-02-10 05:25:41 +00:00
|
|
|
BIC_PRESENT(BIC_PKG__);
|
|
|
|
BIC_PRESENT(BIC_RAM__);
|
|
|
|
if (rapl_joules) {
|
|
|
|
BIC_PRESENT(BIC_Pkg_J);
|
|
|
|
BIC_PRESENT(BIC_Cor_J);
|
|
|
|
BIC_PRESENT(BIC_RAM_J);
|
|
|
|
} else {
|
|
|
|
BIC_PRESENT(BIC_PkgWatt);
|
|
|
|
BIC_PRESENT(BIC_CorWatt);
|
|
|
|
BIC_PRESENT(BIC_RAMWatt);
|
|
|
|
}
|
2013-11-09 05:30:16 +00:00
|
|
|
break;
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT: /* BYT */
|
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT_X: /* AVN */
|
2016-06-16 16:48:20 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_CORES;
|
2017-02-10 05:25:41 +00:00
|
|
|
if (rapl_joules) {
|
|
|
|
BIC_PRESENT(BIC_Pkg_J);
|
|
|
|
BIC_PRESENT(BIC_Cor_J);
|
|
|
|
} else {
|
|
|
|
BIC_PRESENT(BIC_PkgWatt);
|
|
|
|
BIC_PRESENT(BIC_CorWatt);
|
|
|
|
}
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
break;
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_X: /* DNV */
|
2016-06-16 16:48:22 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO | RAPL_CORES_ENERGY_STATUS;
|
2017-02-10 05:25:41 +00:00
|
|
|
BIC_PRESENT(BIC_PKG__);
|
|
|
|
BIC_PRESENT(BIC_RAM__);
|
|
|
|
if (rapl_joules) {
|
|
|
|
BIC_PRESENT(BIC_Pkg_J);
|
|
|
|
BIC_PRESENT(BIC_Cor_J);
|
|
|
|
BIC_PRESENT(BIC_RAM_J);
|
|
|
|
} else {
|
|
|
|
BIC_PRESENT(BIC_PkgWatt);
|
|
|
|
BIC_PRESENT(BIC_CorWatt);
|
|
|
|
BIC_PRESENT(BIC_RAMWatt);
|
|
|
|
}
|
2016-06-16 16:48:22 +00:00
|
|
|
break;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* units on package 0, verify later other packages match */
|
2015-05-25 12:34:28 +00:00
|
|
|
if (get_msr(base_cpu, MSR_RAPL_POWER_UNIT, &msr))
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
rapl_power_units = 1.0 / (1 << (msr & 0xF));
|
2018-08-07 17:17:27 +00:00
|
|
|
if (model == INTEL_FAM6_ATOM_SILVERMONT)
|
2013-11-09 05:30:16 +00:00
|
|
|
rapl_energy_units = 1.0 * (1 << (msr >> 8 & 0x1F)) / 1000000;
|
|
|
|
else
|
|
|
|
rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2014-12-05 05:07:00 +00:00
|
|
|
rapl_dram_energy_units = rapl_dram_energy_units_probe(model, rapl_energy_units);
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
time_unit = msr >> 16 & 0xF;
|
|
|
|
if (time_unit == 0)
|
|
|
|
time_unit = 0xA;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
rapl_time_units = 1.0 / (1 << (time_unit));
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
tdp = get_tdp_intel(model);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
|
2018-08-17 16:34:41 +00:00
|
|
|
}
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
void rapl_probe_amd(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
unsigned int eax, ebx, ecx, edx;
|
|
|
|
unsigned int has_rapl = 0;
|
|
|
|
double tdp;
|
|
|
|
|
|
|
|
if (max_extended_level >= 0x80000007) {
|
|
|
|
__cpuid(0x80000007, eax, ebx, ecx, edx);
|
|
|
|
/* RAPL (Fam 17h) */
|
|
|
|
has_rapl = edx & (1 << 14);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!has_rapl)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (family) {
|
|
|
|
case 0x17: /* Zen, Zen+ */
|
|
|
|
do_rapl = RAPL_AMD_F17H | RAPL_PER_CORE_ENERGY;
|
2018-08-17 16:34:42 +00:00
|
|
|
if (rapl_joules) {
|
|
|
|
BIC_PRESENT(BIC_Pkg_J);
|
2018-08-17 16:34:41 +00:00
|
|
|
BIC_PRESENT(BIC_Cor_J);
|
2018-08-17 16:34:42 +00:00
|
|
|
} else {
|
|
|
|
BIC_PRESENT(BIC_PkgWatt);
|
2018-08-17 16:34:41 +00:00
|
|
|
BIC_PRESENT(BIC_CorWatt);
|
2018-08-17 16:34:42 +00:00
|
|
|
}
|
2018-08-17 16:34:41 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (get_msr(base_cpu, MSR_RAPL_PWR_UNIT, &msr))
|
|
|
|
return;
|
|
|
|
|
|
|
|
rapl_time_units = ldexp(1.0, -(msr >> 16 & 0xf));
|
|
|
|
rapl_energy_units = ldexp(1.0, -(msr >> 8 & 0x1f));
|
|
|
|
rapl_power_units = ldexp(1.0, -(msr & 0xf));
|
|
|
|
|
|
|
|
tdp = get_tdp_amd(model);
|
|
|
|
|
|
|
|
rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
|
|
|
|
if (!quiet)
|
|
|
|
fprintf(outf, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rapl_probe()
|
|
|
|
*
|
|
|
|
* sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_units
|
|
|
|
*/
|
|
|
|
void rapl_probe(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (genuine_intel)
|
|
|
|
rapl_probe_intel(family, model);
|
|
|
|
if (authentic_amd)
|
|
|
|
rapl_probe_amd(family, model);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
}
|
|
|
|
|
2016-03-02 13:50:25 +00:00
|
|
|
void perf_limit_reasons_probe(unsigned int family, unsigned int model)
|
2014-08-15 06:39:52 +00:00
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_HASWELL_CORE: /* HSW */
|
|
|
|
case INTEL_FAM6_HASWELL_GT3E: /* HSW */
|
2014-08-15 06:39:52 +00:00
|
|
|
do_gfx_perf_limit_reasons = 1;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_HASWELL_X: /* HSX */
|
2014-08-15 06:39:52 +00:00
|
|
|
do_core_perf_limit_reasons = 1;
|
|
|
|
do_ring_perf_limit_reasons = 1;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-05 12:14:08 +00:00
|
|
|
void automatic_cstate_conversion_probe(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (is_skx(family, model) || is_bdx(family, model))
|
|
|
|
has_automatic_cstate_conversion = 1;
|
|
|
|
}
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
2017-03-04 23:10:45 +00:00
|
|
|
unsigned int dts, dts2;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
int cpu;
|
|
|
|
|
|
|
|
if (!(do_dts || do_ptm))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu = t->cpu_id;
|
|
|
|
|
|
|
|
/* DTS is per-core, no need to print for each thread */
|
2016-12-23 04:57:55 +00:00
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (cpu_migrate(cpu)) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "Could not migrate to CPU %d\n", cpu);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (do_ptm && (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)) {
|
|
|
|
if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dts = (msr >> 16) & 0x7F;
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_STATUS: 0x%08llx (%d C)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, msr, tcc_activation_temp - dts);
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, &msr))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dts = (msr >> 16) & 0x7F;
|
|
|
|
dts2 = (msr >> 8) & 0x7F;
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-03-04 23:10:45 +00:00
|
|
|
if (do_dts && debug) {
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
unsigned int resolution;
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dts = (msr >> 16) & 0x7F;
|
|
|
|
resolution = (msr >> 27) & 0xF;
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_THERM_STATUS: 0x%08llx (%d C +/- %d)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, msr, tcc_activation_temp - dts, resolution);
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_THERM_INTERRUPT, &msr))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dts = (msr >> 16) & 0x7F;
|
|
|
|
dts2 = (msr >> 8) & 0x7F;
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-27 01:51:02 +00:00
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
void print_power_limit_msr(int cpu, unsigned long long msr, char *label)
|
|
|
|
{
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: %s: %sabled (%f Watts, %f sec, clamp %sabled)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, label,
|
|
|
|
((msr >> 15) & 1) ? "EN" : "DIS",
|
|
|
|
((msr >> 0) & 0x7FFF) * rapl_power_units,
|
|
|
|
(1.0 + (((msr >> 22) & 0x3)/4.0)) * (1 << ((msr >> 17) & 0x1F)) * rapl_time_units,
|
|
|
|
(((msr >> 16) & 1) ? "EN" : "DIS"));
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
2018-08-17 16:34:41 +00:00
|
|
|
const char *msr_name;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
int cpu;
|
|
|
|
|
|
|
|
if (!do_rapl)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* RAPL counters are per package, so print only for 1st thread/package */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu = t->cpu_id;
|
|
|
|
if (cpu_migrate(cpu)) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "Could not migrate to CPU %d\n", cpu);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
if (do_rapl & RAPL_AMD_F17H) {
|
|
|
|
msr_name = "MSR_RAPL_PWR_UNIT";
|
|
|
|
if (get_msr(cpu, MSR_RAPL_PWR_UNIT, &msr))
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
msr_name = "MSR_RAPL_POWER_UNIT";
|
|
|
|
if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr))
|
|
|
|
return -1;
|
|
|
|
}
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2018-08-17 16:34:41 +00:00
|
|
|
fprintf(outf, "cpu%d: %s: 0x%08llx (%f Watts, %f Joules, %f sec.)\n", cpu, msr_name, msr,
|
2017-01-21 07:26:00 +00:00
|
|
|
rapl_power_units, rapl_energy_units, rapl_time_units);
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
if (do_rapl & RAPL_PKG_POWER_INFO) {
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_POWER_INFO, &msr))
|
|
|
|
return -5;
|
|
|
|
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_PKG_POWER_INFO: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, msr,
|
|
|
|
((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
|
|
|
|
((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
|
|
|
|
((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
|
|
|
|
((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
}
|
|
|
|
if (do_rapl & RAPL_PKG) {
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
if (get_msr(cpu, MSR_PKG_POWER_LIMIT, &msr))
|
|
|
|
return -9;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_PKG_POWER_LIMIT: 0x%08llx (%slocked)\n",
|
2017-01-21 07:26:00 +00:00
|
|
|
cpu, msr, (msr >> 63) & 1 ? "" : "UN");
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
|
|
|
print_power_limit_msr(cpu, msr, "PKG Limit #1");
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: PKG Limit #2: %sabled (%f Watts, %f* sec, clamp %sabled)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu,
|
|
|
|
((msr >> 47) & 1) ? "EN" : "DIS",
|
|
|
|
((msr >> 32) & 0x7FFF) * rapl_power_units,
|
|
|
|
(1.0 + (((msr >> 54) & 0x3)/4.0)) * (1 << ((msr >> 49) & 0x1F)) * rapl_time_units,
|
|
|
|
((msr >> 48) & 1) ? "EN" : "DIS");
|
|
|
|
}
|
|
|
|
|
2015-03-26 04:50:30 +00:00
|
|
|
if (do_rapl & RAPL_DRAM_POWER_INFO) {
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
if (get_msr(cpu, MSR_DRAM_POWER_INFO, &msr))
|
|
|
|
return -6;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_DRAM_POWER_INFO,: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, msr,
|
|
|
|
((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
|
|
|
|
((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
|
|
|
|
((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
|
|
|
|
((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
|
2015-03-26 04:50:30 +00:00
|
|
|
}
|
|
|
|
if (do_rapl & RAPL_DRAM) {
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
if (get_msr(cpu, MSR_DRAM_POWER_LIMIT, &msr))
|
|
|
|
return -9;
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_DRAM_POWER_LIMIT: 0x%08llx (%slocked)\n",
|
2017-01-21 07:26:00 +00:00
|
|
|
cpu, msr, (msr >> 31) & 1 ? "" : "UN");
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
|
|
|
print_power_limit_msr(cpu, msr, "DRAM Limit");
|
|
|
|
}
|
2013-11-09 05:30:16 +00:00
|
|
|
if (do_rapl & RAPL_CORE_POLICY) {
|
2017-01-21 07:26:00 +00:00
|
|
|
if (get_msr(cpu, MSR_PP0_POLICY, &msr))
|
|
|
|
return -7;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_PP0_POLICY: %lld\n", cpu, msr & 0xF);
|
2013-11-09 05:30:16 +00:00
|
|
|
}
|
2016-06-16 16:48:20 +00:00
|
|
|
if (do_rapl & RAPL_CORES_POWER_LIMIT) {
|
2017-01-21 07:26:00 +00:00
|
|
|
if (get_msr(cpu, MSR_PP0_POWER_LIMIT, &msr))
|
|
|
|
return -9;
|
|
|
|
fprintf(outf, "cpu%d: MSR_PP0_POWER_LIMIT: 0x%08llx (%slocked)\n",
|
|
|
|
cpu, msr, (msr >> 31) & 1 ? "" : "UN");
|
|
|
|
print_power_limit_msr(cpu, msr, "Cores Limit");
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
}
|
|
|
|
if (do_rapl & RAPL_GFX) {
|
2017-01-21 07:26:00 +00:00
|
|
|
if (get_msr(cpu, MSR_PP1_POLICY, &msr))
|
|
|
|
return -8;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_PP1_POLICY: %lld\n", cpu, msr & 0xF);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (get_msr(cpu, MSR_PP1_POWER_LIMIT, &msr))
|
|
|
|
return -9;
|
|
|
|
fprintf(outf, "cpu%d: MSR_PP1_POWER_LIMIT: 0x%08llx (%slocked)\n",
|
|
|
|
cpu, msr, (msr >> 31) & 1 ? "" : "UN");
|
|
|
|
print_power_limit_msr(cpu, msr, "GFX Limit");
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
/*
|
|
|
|
* SNB adds support for additional MSRs:
|
|
|
|
*
|
|
|
|
* MSR_PKG_C7_RESIDENCY 0x000003fa
|
|
|
|
* MSR_CORE_C7_RESIDENCY 0x000003fe
|
|
|
|
* MSR_PKG_C2_RESIDENCY 0x0000060d
|
|
|
|
*/
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
int has_snb_msrs(unsigned int family, unsigned int model)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SANDYBRIDGE:
|
|
|
|
case INTEL_FAM6_SANDYBRIDGE_X:
|
|
|
|
case INTEL_FAM6_IVYBRIDGE: /* IVB */
|
|
|
|
case INTEL_FAM6_IVYBRIDGE_X: /* IVB Xeon */
|
|
|
|
case INTEL_FAM6_HASWELL_CORE: /* HSW */
|
|
|
|
case INTEL_FAM6_HASWELL_X: /* HSW */
|
|
|
|
case INTEL_FAM6_HASWELL_GT3E: /* HSW */
|
|
|
|
case INTEL_FAM6_BROADWELL_CORE: /* BDW */
|
|
|
|
case INTEL_FAM6_BROADWELL_GT3E: /* BDW */
|
|
|
|
case INTEL_FAM6_BROADWELL_X: /* BDX */
|
|
|
|
case INTEL_FAM6_SKYLAKE_MOBILE: /* SKL */
|
2018-05-31 17:39:07 +00:00
|
|
|
case INTEL_FAM6_CANNONLAKE_MOBILE: /* CNL */
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SKYLAKE_X: /* SKX */
|
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT: /* BXT */
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
|
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_X: /* DNV */
|
2010-10-23 03:53:03 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
/*
|
|
|
|
* HSW adds support for additional MSRs:
|
|
|
|
*
|
2016-04-06 21:15:55 +00:00
|
|
|
* MSR_PKG_C8_RESIDENCY 0x00000630
|
|
|
|
* MSR_PKG_C9_RESIDENCY 0x00000631
|
|
|
|
* MSR_PKG_C10_RESIDENCY 0x00000632
|
|
|
|
*
|
|
|
|
* MSR_PKGC8_IRTL 0x00000633
|
|
|
|
* MSR_PKGC9_IRTL 0x00000634
|
|
|
|
* MSR_PKGC10_IRTL 0x00000635
|
|
|
|
*
|
2015-01-23 05:12:33 +00:00
|
|
|
*/
|
|
|
|
int has_hsw_msrs(unsigned int family, unsigned int model)
|
2012-11-21 13:22:43 +00:00
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2018-12-14 21:26:37 +00:00
|
|
|
case INTEL_FAM6_HASWELL_CORE:
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_BROADWELL_CORE: /* BDW */
|
|
|
|
case INTEL_FAM6_SKYLAKE_MOBILE: /* SKL */
|
2018-05-31 17:39:07 +00:00
|
|
|
case INTEL_FAM6_CANNONLAKE_MOBILE: /* CNL */
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT: /* BXT */
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
|
2015-03-26 04:50:30 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SKL adds support for additional MSRS:
|
|
|
|
*
|
|
|
|
* MSR_PKG_WEIGHTED_CORE_C0_RES 0x00000658
|
|
|
|
* MSR_PKG_ANY_CORE_C0_RES 0x00000659
|
|
|
|
* MSR_PKG_ANY_GFXE_C0_RES 0x0000065A
|
|
|
|
* MSR_PKG_BOTH_CORE_GFXE_C0_RES 0x0000065B
|
|
|
|
*/
|
|
|
|
int has_skl_msrs(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SKYLAKE_MOBILE: /* SKL */
|
2018-05-31 17:39:07 +00:00
|
|
|
case INTEL_FAM6_CANNONLAKE_MOBILE: /* CNL */
|
2012-11-21 13:22:43 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
int is_slm(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
switch (model) {
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT: /* BYT */
|
|
|
|
case INTEL_FAM6_ATOM_SILVERMONT_X: /* AVN */
|
2013-11-09 05:30:16 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-20 16:49:34 +00:00
|
|
|
int is_knl(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
switch (model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_XEON_PHI_KNL: /* KNL */
|
2015-05-20 16:49:34 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-05-31 17:39:07 +00:00
|
|
|
int is_cnl(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (!genuine_intel)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
case INTEL_FAM6_CANNONLAKE_MOBILE: /* CNL */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-14 11:31:00 +00:00
|
|
|
unsigned int get_aperf_mperf_multiplier(unsigned int family, unsigned int model)
|
|
|
|
{
|
|
|
|
if (is_knl(family, model))
|
|
|
|
return 1024;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
#define SLM_BCLK_FREQS 5
|
|
|
|
double slm_freq_table[SLM_BCLK_FREQS] = { 83.3, 100.0, 133.3, 116.7, 80.0};
|
|
|
|
|
|
|
|
double slm_bclk(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr = 3;
|
|
|
|
unsigned int i;
|
|
|
|
double freq;
|
|
|
|
|
2015-05-25 12:34:28 +00:00
|
|
|
if (get_msr(base_cpu, MSR_FSB_FREQ, &msr))
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "SLM BCLK: unknown\n");
|
2013-11-09 05:30:16 +00:00
|
|
|
|
|
|
|
i = msr & 0xf;
|
|
|
|
if (i >= SLM_BCLK_FREQS) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "SLM BCLK[%d] invalid\n", i);
|
2016-04-25 12:03:15 +00:00
|
|
|
i = 3;
|
2013-11-09 05:30:16 +00:00
|
|
|
}
|
|
|
|
freq = slm_freq_table[i];
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2017-01-08 03:40:23 +00:00
|
|
|
fprintf(outf, "SLM BCLK: %.1f Mhz\n", freq);
|
2013-11-09 05:30:16 +00:00
|
|
|
|
|
|
|
return freq;
|
|
|
|
}
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
double discover_bclk(unsigned int family, unsigned int model)
|
|
|
|
{
|
2016-02-10 15:35:17 +00:00
|
|
|
if (has_snb_msrs(family, model) || is_knl(family, model))
|
2010-10-23 03:53:03 +00:00
|
|
|
return 100.00;
|
2013-11-09 05:30:16 +00:00
|
|
|
else if (is_slm(family, model))
|
|
|
|
return slm_bclk();
|
2010-10-23 03:53:03 +00:00
|
|
|
else
|
|
|
|
return 133.33;
|
|
|
|
}
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
/*
|
|
|
|
* MSR_IA32_TEMPERATURE_TARGET indicates the temperature where
|
|
|
|
* the Thermal Control Circuit (TCC) activates.
|
|
|
|
* This is usually equal to tjMax.
|
|
|
|
*
|
|
|
|
* Older processors do not have this MSR, so there we guess,
|
|
|
|
* but also allow cmdline over-ride with -T.
|
|
|
|
*
|
|
|
|
* Several MSR temperature values are in units of degrees-C
|
|
|
|
* below this value, including the Digital Thermal Sensor (DTS),
|
|
|
|
* Package Thermal Management Sensor (PTM), and thermal event thresholds.
|
|
|
|
*/
|
|
|
|
int set_temperature_target(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
unsigned int target_c_local;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
/* tcc_activation_temp is used only for dts or ptm */
|
|
|
|
if (!(do_dts || do_ptm))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* this is a per-package concept */
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu = t->cpu_id;
|
|
|
|
if (cpu_migrate(cpu)) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "Could not migrate to CPU %d\n", cpu);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tcc_activation_temp_override != 0) {
|
|
|
|
tcc_activation_temp = tcc_activation_temp_override;
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: Using cmdline TCC Target (%d C)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, tcc_activation_temp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Temperature Target MSR is Nehalem and newer only */
|
2015-01-23 05:12:33 +00:00
|
|
|
if (!do_nhm_platform_info)
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
goto guess;
|
|
|
|
|
2015-05-25 12:34:28 +00:00
|
|
|
if (get_msr(base_cpu, MSR_IA32_TEMPERATURE_TARGET, &msr))
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
goto guess;
|
|
|
|
|
2014-05-01 09:40:19 +00:00
|
|
|
target_c_local = (msr >> 16) & 0xFF;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C)\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, msr, target_c_local);
|
|
|
|
|
2014-05-01 09:40:19 +00:00
|
|
|
if (!target_c_local)
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
goto guess;
|
|
|
|
|
|
|
|
tcc_activation_temp = target_c_local;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
guess:
|
|
|
|
tcc_activation_temp = TJMAX_DEFAULT;
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d: Guessing tjMax %d C, Please use -T to specify\n",
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
cpu, tcc_activation_temp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-11-21 17:22:47 +00:00
|
|
|
|
2016-03-11 18:26:03 +00:00
|
|
|
void decode_feature_control_msr(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
|
|
|
if (!get_msr(base_cpu, MSR_IA32_FEATURE_CONTROL, &msr))
|
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_FEATURE_CONTROL: 0x%08llx (%sLocked %s)\n",
|
|
|
|
base_cpu, msr,
|
|
|
|
msr & FEATURE_CONTROL_LOCKED ? "" : "UN-",
|
|
|
|
msr & (1 << 18) ? "SGX" : "");
|
|
|
|
}
|
|
|
|
|
2015-11-21 17:22:47 +00:00
|
|
|
void decode_misc_enable_msr(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
2017-06-24 03:45:54 +00:00
|
|
|
if (!genuine_intel)
|
|
|
|
return;
|
|
|
|
|
2015-11-21 17:22:47 +00:00
|
|
|
if (!get_msr(base_cpu, MSR_IA32_MISC_ENABLE, &msr))
|
2017-01-12 04:17:24 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_IA32_MISC_ENABLE: 0x%08llx (%sTCC %sEIST %sMWAIT %sPREFETCH %sTURBO)\n",
|
2015-11-21 17:22:47 +00:00
|
|
|
base_cpu, msr,
|
2017-01-12 04:17:24 +00:00
|
|
|
msr & MSR_IA32_MISC_ENABLE_TM1 ? "" : "No-",
|
|
|
|
msr & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP ? "" : "No-",
|
2017-11-09 04:15:42 +00:00
|
|
|
msr & MSR_IA32_MISC_ENABLE_MWAIT ? "" : "No-",
|
2017-01-12 04:17:24 +00:00
|
|
|
msr & MSR_IA32_MISC_ENABLE_PREFETCH_DISABLE ? "No-" : "",
|
|
|
|
msr & MSR_IA32_MISC_ENABLE_TURBO_DISABLE ? "No-" : "");
|
2015-11-21 17:22:47 +00:00
|
|
|
}
|
|
|
|
|
2017-01-21 06:26:16 +00:00
|
|
|
void decode_misc_feature_control(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
|
|
|
if (!has_misc_feature_control)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!get_msr(base_cpu, MSR_MISC_FEATURE_CONTROL, &msr))
|
|
|
|
fprintf(outf, "cpu%d: MSR_MISC_FEATURE_CONTROL: 0x%08llx (%sL2-Prefetch %sL2-Prefetch-pair %sL1-Prefetch %sL1-IP-Prefetch)\n",
|
|
|
|
base_cpu, msr,
|
|
|
|
msr & (0 << 0) ? "No-" : "",
|
|
|
|
msr & (1 << 0) ? "No-" : "",
|
|
|
|
msr & (2 << 0) ? "No-" : "",
|
|
|
|
msr & (3 << 0) ? "No-" : "");
|
|
|
|
}
|
2015-12-03 06:35:36 +00:00
|
|
|
/*
|
|
|
|
* Decode MSR_MISC_PWR_MGMT
|
|
|
|
*
|
|
|
|
* Decode the bits according to the Nehalem documentation
|
|
|
|
* bit[0] seems to continue to have same meaning going forward
|
|
|
|
* bit[1] less so...
|
|
|
|
*/
|
|
|
|
void decode_misc_pwr_mgmt_msr(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
|
|
|
if (!do_nhm_platform_info)
|
|
|
|
return;
|
|
|
|
|
2017-01-01 18:08:33 +00:00
|
|
|
if (no_MSR_MISC_PWR_MGMT)
|
|
|
|
return;
|
|
|
|
|
2015-12-03 06:35:36 +00:00
|
|
|
if (!get_msr(base_cpu, MSR_MISC_PWR_MGMT, &msr))
|
2016-11-11 22:29:48 +00:00
|
|
|
fprintf(outf, "cpu%d: MSR_MISC_PWR_MGMT: 0x%08llx (%sable-EIST_Coordination %sable-EPB %sable-OOB)\n",
|
2015-12-03 06:35:36 +00:00
|
|
|
base_cpu, msr,
|
|
|
|
msr & (1 << 0) ? "DIS" : "EN",
|
2016-11-11 22:29:48 +00:00
|
|
|
msr & (1 << 1) ? "EN" : "DIS",
|
|
|
|
msr & (1 << 8) ? "EN" : "DIS");
|
2015-12-03 06:35:36 +00:00
|
|
|
}
|
2017-01-08 03:37:48 +00:00
|
|
|
/*
|
|
|
|
* Decode MSR_CC6_DEMOTION_POLICY_CONFIG, MSR_MC6_DEMOTION_POLICY_CONFIG
|
|
|
|
*
|
|
|
|
* This MSRs are present on Silvermont processors,
|
|
|
|
* Intel Atom processor E3000 series (Baytrail), and friends.
|
|
|
|
*/
|
|
|
|
void decode_c6_demotion_policy_msr(void)
|
|
|
|
{
|
|
|
|
unsigned long long msr;
|
|
|
|
|
|
|
|
if (!get_msr(base_cpu, MSR_CC6_DEMOTION_POLICY_CONFIG, &msr))
|
|
|
|
fprintf(outf, "cpu%d: MSR_CC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-CC6-Demotion)\n",
|
|
|
|
base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
|
|
|
|
|
|
|
|
if (!get_msr(base_cpu, MSR_MC6_DEMOTION_POLICY_CONFIG, &msr))
|
|
|
|
fprintf(outf, "cpu%d: MSR_MC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-MC6-Demotion)\n",
|
|
|
|
base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
|
|
|
|
}
|
2015-12-01 06:36:39 +00:00
|
|
|
|
2018-12-14 21:26:37 +00:00
|
|
|
/*
|
|
|
|
* When models are the same, for the purpose of turbostat, reuse
|
|
|
|
*/
|
|
|
|
unsigned int intel_model_duplicates(unsigned int model)
|
|
|
|
{
|
|
|
|
|
|
|
|
switch(model) {
|
|
|
|
case INTEL_FAM6_NEHALEM_EP: /* Core i7, Xeon 5500 series - Bloomfield, Gainstown NHM-EP */
|
|
|
|
case INTEL_FAM6_NEHALEM: /* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */
|
|
|
|
case 0x1F: /* Core i7 and i5 Processor - Nehalem */
|
|
|
|
case INTEL_FAM6_WESTMERE: /* Westmere Client - Clarkdale, Arrandale */
|
|
|
|
case INTEL_FAM6_WESTMERE_EP: /* Westmere EP - Gulftown */
|
|
|
|
return INTEL_FAM6_NEHALEM;
|
|
|
|
|
|
|
|
case INTEL_FAM6_NEHALEM_EX: /* Nehalem-EX Xeon - Beckton */
|
|
|
|
case INTEL_FAM6_WESTMERE_EX: /* Westmere-EX Xeon - Eagleton */
|
|
|
|
return INTEL_FAM6_NEHALEM_EX;
|
|
|
|
|
|
|
|
case INTEL_FAM6_XEON_PHI_KNM:
|
|
|
|
return INTEL_FAM6_XEON_PHI_KNL;
|
|
|
|
|
|
|
|
case INTEL_FAM6_HASWELL_ULT:
|
|
|
|
return INTEL_FAM6_HASWELL_CORE;
|
|
|
|
|
|
|
|
case INTEL_FAM6_BROADWELL_X:
|
|
|
|
case INTEL_FAM6_BROADWELL_XEON_D: /* BDX-DE */
|
|
|
|
return INTEL_FAM6_BROADWELL_X;
|
|
|
|
|
|
|
|
case INTEL_FAM6_SKYLAKE_MOBILE:
|
|
|
|
case INTEL_FAM6_SKYLAKE_DESKTOP:
|
|
|
|
case INTEL_FAM6_KABYLAKE_MOBILE:
|
|
|
|
case INTEL_FAM6_KABYLAKE_DESKTOP:
|
|
|
|
return INTEL_FAM6_SKYLAKE_MOBILE;
|
2019-03-19 23:09:07 +00:00
|
|
|
|
|
|
|
case INTEL_FAM6_ICELAKE_MOBILE:
|
|
|
|
return INTEL_FAM6_CANNONLAKE_MOBILE;
|
2018-12-14 21:26:37 +00:00
|
|
|
}
|
|
|
|
return model;
|
|
|
|
}
|
2015-03-24 00:29:09 +00:00
|
|
|
void process_cpuid()
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2018-08-08 00:22:28 +00:00
|
|
|
unsigned int eax, ebx, ecx, edx;
|
|
|
|
unsigned int fms, family, model, stepping, ecx_flags, edx_flags;
|
2017-01-21 05:50:08 +00:00
|
|
|
unsigned int has_turbo;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
eax = ebx = ecx = edx = 0;
|
|
|
|
|
2016-03-13 07:14:35 +00:00
|
|
|
__cpuid(0, max_level, ebx, ecx, edx);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
if (ebx == 0x756e6547 && ecx == 0x6c65746e && edx == 0x49656e69)
|
2010-10-23 03:53:03 +00:00
|
|
|
genuine_intel = 1;
|
2018-08-08 00:22:28 +00:00
|
|
|
else if (ebx == 0x68747541 && ecx == 0x444d4163 && edx == 0x69746e65)
|
|
|
|
authentic_amd = 1;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "CPUID(0): %.4s%.4s%.4s ",
|
2010-10-23 03:53:03 +00:00
|
|
|
(char *)&ebx, (char *)&edx, (char *)&ecx);
|
|
|
|
|
2016-03-13 07:14:35 +00:00
|
|
|
__cpuid(1, fms, ebx, ecx, edx);
|
2010-10-23 03:53:03 +00:00
|
|
|
family = (fms >> 8) & 0xf;
|
|
|
|
model = (fms >> 4) & 0xf;
|
|
|
|
stepping = fms & 0xf;
|
2018-07-27 11:50:53 +00:00
|
|
|
if (family == 0xf)
|
|
|
|
family += (fms >> 20) & 0xff;
|
|
|
|
if (family >= 6)
|
2010-10-23 03:53:03 +00:00
|
|
|
model += ((fms >> 16) & 0xf) << 4;
|
2018-08-08 00:22:28 +00:00
|
|
|
ecx_flags = ecx;
|
|
|
|
edx_flags = edx;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* check max extended function levels of CPUID.
|
|
|
|
* This is needed to check for invariant TSC.
|
|
|
|
* This check is valid for both Intel and AMD.
|
|
|
|
*/
|
|
|
|
ebx = ecx = edx = 0;
|
2016-03-13 07:14:35 +00:00
|
|
|
__cpuid(0x80000000, max_extended_level, ebx, ecx, edx);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2018-08-08 00:22:28 +00:00
|
|
|
if (!quiet) {
|
|
|
|
fprintf(outf, "0x%x CPUID levels; 0x%x xlevels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n",
|
|
|
|
max_level, max_extended_level, family, model, stepping, family, model, stepping);
|
|
|
|
fprintf(outf, "CPUID(1): %s %s %s %s %s %s %s %s %s %s\n",
|
|
|
|
ecx_flags & (1 << 0) ? "SSE3" : "-",
|
|
|
|
ecx_flags & (1 << 3) ? "MONITOR" : "-",
|
|
|
|
ecx_flags & (1 << 6) ? "SMX" : "-",
|
|
|
|
ecx_flags & (1 << 7) ? "EIST" : "-",
|
|
|
|
ecx_flags & (1 << 8) ? "TM2" : "-",
|
|
|
|
edx_flags & (1 << 4) ? "TSC" : "-",
|
|
|
|
edx_flags & (1 << 5) ? "MSR" : "-",
|
|
|
|
edx_flags & (1 << 22) ? "ACPI-TM" : "-",
|
|
|
|
edx_flags & (1 << 28) ? "HT" : "-",
|
|
|
|
edx_flags & (1 << 29) ? "TM" : "-");
|
|
|
|
}
|
2018-12-14 21:26:37 +00:00
|
|
|
if (genuine_intel)
|
|
|
|
model = intel_model_duplicates(model);
|
2018-08-08 00:22:28 +00:00
|
|
|
|
|
|
|
if (!(edx_flags & (1 << 5)))
|
|
|
|
errx(1, "CPUID: no MSR");
|
|
|
|
|
2015-11-23 07:30:51 +00:00
|
|
|
if (max_extended_level >= 0x80000007) {
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
/*
|
|
|
|
* Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
|
|
|
|
* this check is valid for both Intel and AMD
|
|
|
|
*/
|
2016-03-13 07:14:35 +00:00
|
|
|
__cpuid(0x80000007, eax, ebx, ecx, edx);
|
2015-01-23 05:12:33 +00:00
|
|
|
has_invariant_tsc = edx & (1 << 8);
|
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* APERF/MPERF is advertised by CPUID.EAX=0x6: ECX.bit0
|
|
|
|
* this check is valid for both Intel and AMD
|
|
|
|
*/
|
|
|
|
|
2016-03-13 07:14:35 +00:00
|
|
|
__cpuid(0x6, eax, ebx, ecx, edx);
|
2011-01-21 14:11:19 +00:00
|
|
|
has_aperf = ecx & (1 << 0);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (has_aperf) {
|
|
|
|
BIC_PRESENT(BIC_Avg_MHz);
|
|
|
|
BIC_PRESENT(BIC_Busy);
|
|
|
|
BIC_PRESENT(BIC_Bzy_MHz);
|
|
|
|
}
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
do_dts = eax & (1 << 0);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (do_dts)
|
|
|
|
BIC_PRESENT(BIC_CoreTmp);
|
2017-01-21 05:50:08 +00:00
|
|
|
has_turbo = eax & (1 << 1);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
do_ptm = eax & (1 << 6);
|
2017-02-10 05:25:41 +00:00
|
|
|
if (do_ptm)
|
|
|
|
BIC_PRESENT(BIC_PkgTmp);
|
2015-12-01 06:36:39 +00:00
|
|
|
has_hwp = eax & (1 << 7);
|
|
|
|
has_hwp_notify = eax & (1 << 8);
|
|
|
|
has_hwp_activity_window = eax & (1 << 9);
|
|
|
|
has_hwp_epp = eax & (1 << 10);
|
|
|
|
has_hwp_pkg = eax & (1 << 11);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
has_epb = ecx & (1 << 3);
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2017-01-21 05:50:08 +00:00
|
|
|
fprintf(outf, "CPUID(6): %sAPERF, %sTURBO, %sDTS, %sPTM, %sHWP, "
|
2015-12-01 06:36:39 +00:00
|
|
|
"%sHWPnotify, %sHWPwindow, %sHWPepp, %sHWPpkg, %sEPB\n",
|
|
|
|
has_aperf ? "" : "No-",
|
2017-01-21 05:50:08 +00:00
|
|
|
has_turbo ? "" : "No-",
|
2015-12-01 06:36:39 +00:00
|
|
|
do_dts ? "" : "No-",
|
|
|
|
do_ptm ? "" : "No-",
|
|
|
|
has_hwp ? "" : "No-",
|
|
|
|
has_hwp_notify ? "" : "No-",
|
|
|
|
has_hwp_activity_window ? "" : "No-",
|
|
|
|
has_hwp_epp ? "" : "No-",
|
|
|
|
has_hwp_pkg ? "" : "No-",
|
|
|
|
has_epb ? "" : "No-");
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2015-11-21 17:22:47 +00:00
|
|
|
decode_misc_enable_msr();
|
|
|
|
|
2017-01-21 06:26:16 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (max_level >= 0x7 && !quiet) {
|
2016-03-11 18:26:03 +00:00
|
|
|
int has_sgx;
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2016-03-11 18:26:03 +00:00
|
|
|
ecx = 0;
|
|
|
|
|
|
|
|
__cpuid_count(0x7, 0, eax, ebx, ecx, edx);
|
|
|
|
|
|
|
|
has_sgx = ebx & (1 << 2);
|
|
|
|
fprintf(outf, "CPUID(7): %sSGX\n", has_sgx ? "" : "No-");
|
|
|
|
|
|
|
|
if (has_sgx)
|
|
|
|
decode_feature_control_msr();
|
|
|
|
}
|
|
|
|
|
2015-11-23 07:30:51 +00:00
|
|
|
if (max_level >= 0x15) {
|
2015-04-02 01:02:57 +00:00
|
|
|
unsigned int eax_crystal;
|
|
|
|
unsigned int ebx_tsc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CPUID 15H TSC/Crystal ratio, possibly Crystal Hz
|
|
|
|
*/
|
|
|
|
eax_crystal = ebx_tsc = crystal_hz = edx = 0;
|
2016-03-13 07:14:35 +00:00
|
|
|
__cpuid(0x15, eax_crystal, ebx_tsc, crystal_hz, edx);
|
2015-04-02 01:02:57 +00:00
|
|
|
|
|
|
|
if (ebx_tsc != 0) {
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet && (ebx != 0))
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "CPUID(0x15): eax_crystal: %d ebx_tsc: %d ecx_crystal_hz: %d\n",
|
2015-04-02 01:02:57 +00:00
|
|
|
eax_crystal, ebx_tsc, crystal_hz);
|
|
|
|
|
|
|
|
if (crystal_hz == 0)
|
|
|
|
switch(model) {
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_SKYLAKE_MOBILE: /* SKL */
|
2016-04-06 21:15:57 +00:00
|
|
|
crystal_hz = 24000000; /* 24.0 MHz */
|
|
|
|
break;
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_X: /* DNV */
|
2016-04-06 21:15:58 +00:00
|
|
|
crystal_hz = 25000000; /* 25.0 MHz */
|
|
|
|
break;
|
2016-06-17 03:22:37 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT: /* BXT */
|
2018-08-07 17:17:27 +00:00
|
|
|
case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
|
2016-04-06 21:15:57 +00:00
|
|
|
crystal_hz = 19200000; /* 19.2 MHz */
|
2015-04-02 01:02:57 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
crystal_hz = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (crystal_hz) {
|
|
|
|
tsc_hz = (unsigned long long) crystal_hz * ebx_tsc / eax_crystal;
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "TSC: %lld MHz (%d Hz * %d / %d / 1000000)\n",
|
2015-04-02 01:02:57 +00:00
|
|
|
tsc_hz / 1000000, crystal_hz, ebx_tsc, eax_crystal);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-11-23 07:30:51 +00:00
|
|
|
if (max_level >= 0x16) {
|
|
|
|
unsigned int base_mhz, max_mhz, bus_mhz, edx;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CPUID 16H Base MHz, Max MHz, Bus MHz
|
|
|
|
*/
|
|
|
|
base_mhz = max_mhz = bus_mhz = edx = 0;
|
|
|
|
|
2016-03-13 07:14:35 +00:00
|
|
|
__cpuid(0x16, base_mhz, max_mhz, bus_mhz, edx);
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "CPUID(0x16): base_mhz: %d max_mhz: %d bus_mhz: %d\n",
|
2015-11-23 07:30:51 +00:00
|
|
|
base_mhz, max_mhz, bus_mhz);
|
|
|
|
}
|
2015-04-02 01:02:57 +00:00
|
|
|
|
2015-09-14 11:31:00 +00:00
|
|
|
if (has_aperf)
|
|
|
|
aperf_mperf_multiplier = get_aperf_mperf_multiplier(family, model);
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
BIC_PRESENT(BIC_IRQ);
|
|
|
|
BIC_PRESENT(BIC_TSC_MHz);
|
|
|
|
|
|
|
|
if (probe_nhm_msrs(family, model)) {
|
|
|
|
do_nhm_platform_info = 1;
|
|
|
|
BIC_PRESENT(BIC_CPU_c1);
|
|
|
|
BIC_PRESENT(BIC_CPU_c3);
|
|
|
|
BIC_PRESENT(BIC_CPU_c6);
|
|
|
|
BIC_PRESENT(BIC_SMI);
|
|
|
|
}
|
2015-01-23 05:12:33 +00:00
|
|
|
do_snb_cstates = has_snb_msrs(family, model);
|
2017-02-10 05:25:41 +00:00
|
|
|
|
|
|
|
if (do_snb_cstates)
|
|
|
|
BIC_PRESENT(BIC_CPU_c7);
|
|
|
|
|
2016-04-06 21:15:55 +00:00
|
|
|
do_irtl_snb = has_snb_msrs(family, model);
|
2017-01-27 05:50:45 +00:00
|
|
|
if (do_snb_cstates && (pkg_cstate_limit >= PCL__2))
|
|
|
|
BIC_PRESENT(BIC_Pkgpc2);
|
|
|
|
if (pkg_cstate_limit >= PCL__3)
|
|
|
|
BIC_PRESENT(BIC_Pkgpc3);
|
|
|
|
if (pkg_cstate_limit >= PCL__6)
|
|
|
|
BIC_PRESENT(BIC_Pkgpc6);
|
|
|
|
if (do_snb_cstates && (pkg_cstate_limit >= PCL__7))
|
|
|
|
BIC_PRESENT(BIC_Pkgpc7);
|
2017-02-10 05:27:20 +00:00
|
|
|
if (has_slv_msrs(family, model)) {
|
2017-01-27 05:50:45 +00:00
|
|
|
BIC_NOT_PRESENT(BIC_Pkgpc2);
|
|
|
|
BIC_NOT_PRESENT(BIC_Pkgpc3);
|
|
|
|
BIC_PRESENT(BIC_Pkgpc6);
|
|
|
|
BIC_NOT_PRESENT(BIC_Pkgpc7);
|
2017-02-10 05:27:20 +00:00
|
|
|
BIC_PRESENT(BIC_Mod_c6);
|
|
|
|
use_c1_residency_msr = 1;
|
|
|
|
}
|
tools/power turbostat: Denverton: use HW CC1 counter, skip C3, C7
The CC1 column in tubostat can be computed by subtracting
the core c-state residency countes from the total Cx residency.
CC1 = (Idle_time_as_measured by MPERF) - (all core C-states with
residency counters)
However, as the underlying counter reads are not atomic,
error can be noticed in this calculations, especially
when the numbers are small.
Denverton has a hardware CC1 residency counter
to improve the accuracy of the cc1 statistic -- use it.
At the same time, Denverton has no concept of CC3, PC3, CC7, PC7,
so skip collecting and printing those columns.
Finally, a note of clarification.
Turbostat prints the standard PC2 residency counter,
but on Denverton hardware, that actually means PC1E.
Turbostat prints the standard PC6 residency counter,
but on Denverton hardware, that actually means PC2.
At this point, we document that differnce in this commit message,
rather than adding a quirk to the software.
Signed-off-by: Len Brown <len.brown@intel.com>
2017-01-27 07:13:27 +00:00
|
|
|
if (is_dnv(family, model)) {
|
|
|
|
BIC_PRESENT(BIC_CPU_c1);
|
|
|
|
BIC_NOT_PRESENT(BIC_CPU_c3);
|
|
|
|
BIC_NOT_PRESENT(BIC_Pkgpc3);
|
|
|
|
BIC_NOT_PRESENT(BIC_CPU_c7);
|
|
|
|
BIC_NOT_PRESENT(BIC_Pkgpc7);
|
|
|
|
use_c1_residency_msr = 1;
|
|
|
|
}
|
2017-01-27 07:36:41 +00:00
|
|
|
if (is_skx(family, model)) {
|
|
|
|
BIC_NOT_PRESENT(BIC_CPU_c3);
|
|
|
|
BIC_NOT_PRESENT(BIC_Pkgpc3);
|
|
|
|
BIC_NOT_PRESENT(BIC_CPU_c7);
|
|
|
|
BIC_NOT_PRESENT(BIC_Pkgpc7);
|
|
|
|
}
|
2017-02-10 06:56:47 +00:00
|
|
|
if (is_bdx(family, model)) {
|
|
|
|
BIC_NOT_PRESENT(BIC_CPU_c7);
|
|
|
|
BIC_NOT_PRESENT(BIC_Pkgpc7);
|
|
|
|
}
|
2017-01-27 05:50:45 +00:00
|
|
|
if (has_hsw_msrs(family, model)) {
|
|
|
|
BIC_PRESENT(BIC_Pkgpc8);
|
|
|
|
BIC_PRESENT(BIC_Pkgpc9);
|
|
|
|
BIC_PRESENT(BIC_Pkgpc10);
|
|
|
|
}
|
2016-04-06 21:15:55 +00:00
|
|
|
do_irtl_hsw = has_hsw_msrs(family, model);
|
2017-05-21 00:11:55 +00:00
|
|
|
if (has_skl_msrs(family, model)) {
|
|
|
|
BIC_PRESENT(BIC_Totl_c0);
|
|
|
|
BIC_PRESENT(BIC_Any_c0);
|
|
|
|
BIC_PRESENT(BIC_GFX_c0);
|
|
|
|
BIC_PRESENT(BIC_CPUGFX);
|
|
|
|
}
|
2013-11-09 05:30:16 +00:00
|
|
|
do_slm_cstates = is_slm(family, model);
|
2015-05-20 16:49:34 +00:00
|
|
|
do_knl_cstates = is_knl(family, model);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2019-03-19 21:55:06 +00:00
|
|
|
if (do_slm_cstates || do_knl_cstates || is_cnl(family, model))
|
2019-03-19 21:52:32 +00:00
|
|
|
BIC_NOT_PRESENT(BIC_CPU_c3);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2015-12-03 06:35:36 +00:00
|
|
|
decode_misc_pwr_mgmt_msr();
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet && has_slv_msrs(family, model))
|
2017-01-08 03:37:48 +00:00
|
|
|
decode_c6_demotion_policy_msr();
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
rapl_probe(family, model);
|
2014-08-15 06:39:52 +00:00
|
|
|
perf_limit_reasons_probe(family, model);
|
2017-09-05 12:14:08 +00:00
|
|
|
automatic_cstate_conversion_probe(family, model);
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2016-03-02 13:50:25 +00:00
|
|
|
dump_cstate_pstate_config_info(family, model);
|
2015-03-24 00:29:09 +00:00
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
if (!quiet)
|
|
|
|
dump_sysfs_cstate_config();
|
2017-02-22 05:11:12 +00:00
|
|
|
if (!quiet)
|
|
|
|
dump_sysfs_pstate_config();
|
2017-02-09 23:25:22 +00:00
|
|
|
|
2015-09-26 04:12:38 +00:00
|
|
|
if (has_skl_msrs(family, model))
|
|
|
|
calculate_tsc_tweak();
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (!access("/sys/class/drm/card0/power/rc6_residency_ms", R_OK))
|
|
|
|
BIC_PRESENT(BIC_GFX_rc6);
|
2016-02-27 06:28:12 +00:00
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
if (!access("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", R_OK))
|
|
|
|
BIC_PRESENT(BIC_GFXMHz);
|
2016-02-27 05:37:54 +00:00
|
|
|
|
2018-06-01 16:35:53 +00:00
|
|
|
if (!access("/sys/devices/system/cpu/cpuidle/low_power_idle_cpu_residency_us", R_OK))
|
|
|
|
BIC_PRESENT(BIC_CPU_LPI);
|
|
|
|
else
|
|
|
|
BIC_NOT_PRESENT(BIC_CPU_LPI);
|
|
|
|
|
|
|
|
if (!access("/sys/devices/system/cpu/cpuidle/low_power_idle_system_residency_us", R_OK))
|
|
|
|
BIC_PRESENT(BIC_SYS_LPI);
|
|
|
|
else
|
|
|
|
BIC_NOT_PRESENT(BIC_SYS_LPI);
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2017-01-21 06:26:16 +00:00
|
|
|
decode_misc_feature_control();
|
|
|
|
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
return;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* in /dev/cpu/ return success for names that are numbers
|
|
|
|
* ie. filter out ".", "..", "microcode".
|
|
|
|
*/
|
|
|
|
int dir_filter(const struct dirent *dirp)
|
|
|
|
{
|
|
|
|
if (isdigit(dirp->d_name[0]))
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int open_dev_cpu_msr(int dummy1)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
void topology_probe()
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int max_core_id = 0;
|
|
|
|
int max_package_id = 0;
|
2019-02-15 03:17:40 +00:00
|
|
|
int max_die_id = 0;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
int max_siblings = 0;
|
|
|
|
|
|
|
|
/* Initialize num_cpus, max_cpu_num */
|
2018-06-01 14:04:28 +00:00
|
|
|
set_max_cpu_num();
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
topo.num_cpus = 0;
|
|
|
|
for_all_proc_cpus(count_cpus);
|
|
|
|
if (!summary_only && topo.num_cpus > 1)
|
2017-02-10 05:25:41 +00:00
|
|
|
BIC_PRESENT(BIC_CPU);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 1)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
cpus = calloc(1, (topo.max_cpu_num + 1) * sizeof(struct cpu_topology));
|
2013-08-21 00:20:18 +00:00
|
|
|
if (cpus == NULL)
|
|
|
|
err(1, "calloc cpus");
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate and initialize cpu_present_set
|
|
|
|
*/
|
|
|
|
cpu_present_set = CPU_ALLOC((topo.max_cpu_num + 1));
|
2013-08-21 00:20:18 +00:00
|
|
|
if (cpu_present_set == NULL)
|
|
|
|
err(3, "CPU_ALLOC");
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
cpu_present_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
|
|
|
|
CPU_ZERO_S(cpu_present_setsize, cpu_present_set);
|
|
|
|
for_all_proc_cpus(mark_cpu_present);
|
|
|
|
|
2017-02-11 04:54:15 +00:00
|
|
|
/*
|
|
|
|
* Validate that all cpus in cpu_subset are also in cpu_present_set
|
|
|
|
*/
|
|
|
|
for (i = 0; i < CPU_SUBSET_MAXCPUS; ++i) {
|
|
|
|
if (CPU_ISSET_S(i, cpu_subset_size, cpu_subset))
|
|
|
|
if (!CPU_ISSET_S(i, cpu_present_setsize, cpu_present_set))
|
|
|
|
err(1, "cpu%d not present", i);
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/*
|
|
|
|
* Allocate and initialize cpu_affinity_set
|
|
|
|
*/
|
|
|
|
cpu_affinity_set = CPU_ALLOC((topo.max_cpu_num + 1));
|
2013-08-21 00:20:18 +00:00
|
|
|
if (cpu_affinity_set == NULL)
|
|
|
|
err(3, "CPU_ALLOC");
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
cpu_affinity_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
|
|
|
|
CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
|
|
|
|
|
2018-06-01 14:04:31 +00:00
|
|
|
for_all_proc_cpus(init_thread_id);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For online cpus
|
|
|
|
* find max_core_id, max_package_id
|
|
|
|
*/
|
|
|
|
for (i = 0; i <= topo.max_cpu_num; ++i) {
|
|
|
|
int siblings;
|
|
|
|
|
|
|
|
if (cpu_is_not_present(i)) {
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 1)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "cpu%d NOT PRESENT\n", i);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-06-02 02:08:58 +00:00
|
|
|
cpus[i].logical_cpu_id = i;
|
|
|
|
|
|
|
|
/* get package information */
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
cpus[i].physical_package_id = get_physical_package_id(i);
|
|
|
|
if (cpus[i].physical_package_id > max_package_id)
|
|
|
|
max_package_id = cpus[i].physical_package_id;
|
|
|
|
|
2019-02-15 03:17:40 +00:00
|
|
|
/* get die information */
|
|
|
|
cpus[i].die_id = get_die_id(i);
|
|
|
|
if (cpus[i].die_id > max_die_id)
|
|
|
|
max_die_id = cpus[i].die_id;
|
|
|
|
|
2018-06-02 02:08:58 +00:00
|
|
|
/* get numa node information */
|
2018-06-01 14:04:30 +00:00
|
|
|
cpus[i].physical_node_id = get_physical_node_id(&cpus[i]);
|
|
|
|
if (cpus[i].physical_node_id > topo.max_node_num)
|
|
|
|
topo.max_node_num = cpus[i].physical_node_id;
|
2018-06-02 02:08:58 +00:00
|
|
|
|
|
|
|
/* get core information */
|
|
|
|
cpus[i].physical_core_id = get_core_id(i);
|
|
|
|
if (cpus[i].physical_core_id > max_core_id)
|
|
|
|
max_core_id = cpus[i].physical_core_id;
|
|
|
|
|
|
|
|
/* get thread information */
|
|
|
|
siblings = get_thread_siblings(&cpus[i]);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (siblings > max_siblings)
|
|
|
|
max_siblings = siblings;
|
tools/power turbostat: fix bogus summary values
This patch fixes a regression introduced in
commit 8cb48b32a5de ("tools/power turbostat: track thread ID in cpu_topology")
Turbostat uses incorrect cores number ('topo.num_cores') - its value is count
of logical CPUs, instead of count of physical cores. So it is twice as large as
it should be on a typical Intel system. For example, on a 6 core Xeon system
'topo.num_cores' is 12, and on a 52 core Xeon system 'topo.num_cores' is 104.
And interestingly, on a 68-core Knights Landing Intel system 'topo.num_cores'
is 272, because this system has 4 logical CPUs per core.
As a result, some of the turbostat calculations are incorrect. For example,
on idle 52-core Xeon system when all cores are ~99% in Core C6 (CPU%c6), the
summary (very first) line shows ~48% Core C6, while it should be ~99%.
This patch fixes the problem by fixing 'topo.num_cores' calculation.
Was:
1. Init 'thread_id' for all CPUs to -1
2. Run 'get_thread_siblings()' which sets it to 0 or 1
3. Increment 'topo.num_cores' when thread_id != -1 (bug!)
Now:
1. Init 'thread_id' for all CPUs to -1
2. Run 'get_thread_siblings()' which sets it to 0 or 1
3. Increment 'topo.num_cores' when thread_id is not 0
I did not have a chance to test this on an AMD machine, and only tested on a
couple of Intel Xeons (6 and 52 cores).
Reported-by: Vladislav Govtva <vladislav.govtva@intel.com>
Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2018-07-25 08:52:06 +00:00
|
|
|
if (cpus[i].thread_id == 0)
|
2018-06-01 14:04:31 +00:00
|
|
|
topo.num_cores++;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2018-06-01 14:04:30 +00:00
|
|
|
|
2018-06-01 14:04:33 +00:00
|
|
|
topo.cores_per_node = max_core_id + 1;
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 1)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "max_core_id %d, sizing for %d cores per package\n",
|
2018-06-01 14:04:33 +00:00
|
|
|
max_core_id, topo.cores_per_node);
|
|
|
|
if (!summary_only && topo.cores_per_node > 1)
|
2017-02-10 05:25:41 +00:00
|
|
|
BIC_PRESENT(BIC_Core);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2019-02-15 03:17:40 +00:00
|
|
|
topo.num_die = max_die_id + 1;
|
|
|
|
if (debug > 1)
|
|
|
|
fprintf(outf, "max_die_id %d, sizing for %d die\n",
|
|
|
|
max_die_id, topo.num_die);
|
|
|
|
if (!summary_only && topo.num_die > 1)
|
|
|
|
BIC_PRESENT(BIC_Die);
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
topo.num_packages = max_package_id + 1;
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 1)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "max_package_id %d, sizing for %d packages\n",
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
max_package_id, topo.num_packages);
|
2017-02-22 04:43:41 +00:00
|
|
|
if (!summary_only && topo.num_packages > 1)
|
2017-02-10 05:25:41 +00:00
|
|
|
BIC_PRESENT(BIC_Package);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2018-06-01 14:04:30 +00:00
|
|
|
set_node_data();
|
|
|
|
if (debug > 1)
|
2018-06-01 14:04:33 +00:00
|
|
|
fprintf(outf, "nodes_per_pkg %d\n", topo.nodes_per_pkg);
|
2018-06-01 14:04:35 +00:00
|
|
|
if (!summary_only && topo.nodes_per_pkg > 1)
|
|
|
|
BIC_PRESENT(BIC_Node);
|
2018-06-01 14:04:30 +00:00
|
|
|
|
2018-06-01 14:04:33 +00:00
|
|
|
topo.threads_per_core = max_siblings;
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 1)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "max_siblings %d\n", max_siblings);
|
2018-07-26 13:08:54 +00:00
|
|
|
|
|
|
|
if (debug < 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i <= topo.max_cpu_num; ++i) {
|
2018-09-22 02:26:57 +00:00
|
|
|
if (cpu_is_not_present(i))
|
|
|
|
continue;
|
2018-07-26 13:08:54 +00:00
|
|
|
fprintf(outf,
|
2019-02-15 03:17:40 +00:00
|
|
|
"cpu %d pkg %d die %d node %d lnode %d core %d thread %d\n",
|
|
|
|
i, cpus[i].physical_package_id, cpus[i].die_id,
|
2018-07-26 13:08:54 +00:00
|
|
|
cpus[i].physical_node_id,
|
|
|
|
cpus[i].logical_node_id,
|
|
|
|
cpus[i].physical_core_id,
|
|
|
|
cpus[i].thread_id);
|
|
|
|
}
|
|
|
|
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2018-06-01 14:04:34 +00:00
|
|
|
allocate_counters(struct thread_data **t, struct core_data **c,
|
|
|
|
struct pkg_data **p)
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
{
|
|
|
|
int i;
|
2018-06-01 14:04:34 +00:00
|
|
|
int num_cores = topo.cores_per_node * topo.nodes_per_pkg *
|
|
|
|
topo.num_packages;
|
|
|
|
int num_threads = topo.threads_per_core * num_cores;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2018-06-01 14:04:34 +00:00
|
|
|
*t = calloc(num_threads, sizeof(struct thread_data));
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (*t == NULL)
|
|
|
|
goto error;
|
|
|
|
|
2018-06-01 14:04:34 +00:00
|
|
|
for (i = 0; i < num_threads; i++)
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
(*t)[i].cpu_id = -1;
|
|
|
|
|
2018-06-01 14:04:34 +00:00
|
|
|
*c = calloc(num_cores, sizeof(struct core_data));
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (*c == NULL)
|
|
|
|
goto error;
|
|
|
|
|
2018-06-01 14:04:34 +00:00
|
|
|
for (i = 0; i < num_cores; i++)
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
(*c)[i].core_id = -1;
|
|
|
|
|
2017-02-10 03:22:13 +00:00
|
|
|
*p = calloc(topo.num_packages, sizeof(struct pkg_data));
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
if (*p == NULL)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
for (i = 0; i < topo.num_packages; i++)
|
|
|
|
(*p)[i].package_id = i;
|
|
|
|
|
|
|
|
return;
|
|
|
|
error:
|
2013-08-21 00:20:18 +00:00
|
|
|
err(1, "calloc counters");
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* init_counter()
|
|
|
|
*
|
|
|
|
* set FIRST_THREAD_IN_CORE and FIRST_CORE_IN_PACKAGE
|
|
|
|
*/
|
|
|
|
void init_counter(struct thread_data *thread_base, struct core_data *core_base,
|
2018-06-01 14:04:31 +00:00
|
|
|
struct pkg_data *pkg_base, int cpu_id)
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
{
|
2018-06-01 14:04:31 +00:00
|
|
|
int pkg_id = cpus[cpu_id].physical_package_id;
|
2018-06-01 14:04:34 +00:00
|
|
|
int node_id = cpus[cpu_id].logical_node_id;
|
2018-06-01 14:04:31 +00:00
|
|
|
int core_id = cpus[cpu_id].physical_core_id;
|
|
|
|
int thread_id = cpus[cpu_id].thread_id;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
struct thread_data *t;
|
|
|
|
struct core_data *c;
|
|
|
|
struct pkg_data *p;
|
|
|
|
|
2018-06-08 22:15:12 +00:00
|
|
|
|
|
|
|
/* Workaround for systems where physical_node_id==-1
|
|
|
|
* and logical_node_id==(-1 - topo.num_cpus)
|
|
|
|
*/
|
|
|
|
if (node_id < 0)
|
|
|
|
node_id = 0;
|
|
|
|
|
2018-06-01 14:04:34 +00:00
|
|
|
t = GET_THREAD(thread_base, thread_id, core_id, node_id, pkg_id);
|
|
|
|
c = GET_CORE(core_base, core_id, node_id, pkg_id);
|
2018-06-01 14:04:31 +00:00
|
|
|
p = GET_PKG(pkg_base, pkg_id);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
|
|
|
t->cpu_id = cpu_id;
|
2018-06-01 14:04:31 +00:00
|
|
|
if (thread_id == 0) {
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
t->flags |= CPU_IS_FIRST_THREAD_IN_CORE;
|
|
|
|
if (cpu_is_first_core_in_package(cpu_id))
|
|
|
|
t->flags |= CPU_IS_FIRST_CORE_IN_PACKAGE;
|
|
|
|
}
|
|
|
|
|
2018-06-01 14:04:31 +00:00
|
|
|
c->core_id = core_id;
|
|
|
|
p->package_id = pkg_id;
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int initialize_counters(int cpu_id)
|
|
|
|
{
|
2018-06-01 14:04:31 +00:00
|
|
|
init_counter(EVEN_COUNTERS, cpu_id);
|
|
|
|
init_counter(ODD_COUNTERS, cpu_id);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void allocate_output_buffer()
|
|
|
|
{
|
2014-01-23 15:13:15 +00:00
|
|
|
output_buffer = calloc(1, (1 + topo.num_cpus) * 1024);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
outp = output_buffer;
|
2013-08-21 00:20:18 +00:00
|
|
|
if (outp == NULL)
|
|
|
|
err(-1, "calloc output buffer");
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
}
|
2016-02-27 01:51:02 +00:00
|
|
|
void allocate_fd_percpu(void)
|
|
|
|
{
|
2016-04-22 08:13:23 +00:00
|
|
|
fd_percpu = calloc(topo.max_cpu_num + 1, sizeof(int));
|
2016-02-27 01:51:02 +00:00
|
|
|
if (fd_percpu == NULL)
|
|
|
|
err(-1, "calloc fd_percpu");
|
|
|
|
}
|
2016-02-27 04:48:05 +00:00
|
|
|
void allocate_irq_buffers(void)
|
|
|
|
{
|
|
|
|
irq_column_2_cpu = calloc(topo.num_cpus, sizeof(int));
|
|
|
|
if (irq_column_2_cpu == NULL)
|
|
|
|
err(-1, "calloc %d", topo.num_cpus);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
|
2016-04-22 08:13:23 +00:00
|
|
|
irqs_per_cpu = calloc(topo.max_cpu_num + 1, sizeof(int));
|
2016-02-27 04:48:05 +00:00
|
|
|
if (irqs_per_cpu == NULL)
|
2016-04-22 08:13:23 +00:00
|
|
|
err(-1, "calloc %d", topo.max_cpu_num + 1);
|
2016-02-27 04:48:05 +00:00
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
void setup_all_buffers(void)
|
|
|
|
{
|
|
|
|
topology_probe();
|
2016-02-27 04:48:05 +00:00
|
|
|
allocate_irq_buffers();
|
2016-02-27 01:51:02 +00:00
|
|
|
allocate_fd_percpu();
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
allocate_counters(&thread_even, &core_even, &package_even);
|
|
|
|
allocate_counters(&thread_odd, &core_odd, &package_odd);
|
|
|
|
allocate_output_buffer();
|
|
|
|
for_all_proc_cpus(initialize_counters);
|
|
|
|
}
|
2014-01-23 15:13:15 +00:00
|
|
|
|
2015-05-25 12:34:28 +00:00
|
|
|
void set_base_cpu(void)
|
|
|
|
{
|
|
|
|
base_cpu = sched_getcpu();
|
|
|
|
if (base_cpu < 0)
|
|
|
|
err(-ENODEV, "No valid cpus found");
|
|
|
|
|
|
|
|
if (debug > 1)
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "base_cpu = %d\n", base_cpu);
|
2015-05-25 12:34:28 +00:00
|
|
|
}
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
void turbostat_init()
|
|
|
|
{
|
2015-05-25 12:34:28 +00:00
|
|
|
setup_all_buffers();
|
|
|
|
set_base_cpu();
|
2010-10-23 03:53:03 +00:00
|
|
|
check_dev_msr();
|
2014-08-15 04:36:50 +00:00
|
|
|
check_permissions();
|
2015-03-24 00:29:09 +00:00
|
|
|
process_cpuid();
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2015-12-01 06:36:39 +00:00
|
|
|
for_all_cpus(print_hwp, ODD_COUNTERS);
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
for_all_cpus(print_epb, ODD_COUNTERS);
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2014-08-15 06:39:52 +00:00
|
|
|
for_all_cpus(print_perf_limit, ODD_COUNTERS);
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
for_all_cpus(print_rapl, ODD_COUNTERS);
|
|
|
|
|
|
|
|
for_all_cpus(set_temperature_target, ODD_COUNTERS);
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
for_all_cpus(print_thermal, ODD_COUNTERS);
|
2016-04-06 21:15:55 +00:00
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet && do_irtl_snb)
|
2016-04-06 21:15:55 +00:00
|
|
|
print_irtl();
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int fork_it(char **argv)
|
|
|
|
{
|
|
|
|
pid_t child_pid;
|
2012-11-01 04:08:19 +00:00
|
|
|
int status;
|
2012-06-04 03:24:00 +00:00
|
|
|
|
2017-02-15 03:07:52 +00:00
|
|
|
snapshot_proc_sysfs_files();
|
2012-11-01 04:08:19 +00:00
|
|
|
status = for_all_cpus(get_counters, EVEN_COUNTERS);
|
2018-06-06 21:44:48 +00:00
|
|
|
first_counter_read = 0;
|
2012-11-01 04:08:19 +00:00
|
|
|
if (status)
|
|
|
|
exit(status);
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/* clear affinity side-effect of get_counters() */
|
|
|
|
sched_setaffinity(0, cpu_present_setsize, cpu_present_set);
|
2010-10-23 03:53:03 +00:00
|
|
|
gettimeofday(&tv_even, (struct timezone *)NULL);
|
|
|
|
|
|
|
|
child_pid = fork();
|
|
|
|
if (!child_pid) {
|
|
|
|
/* child */
|
|
|
|
execvp(argv[0], argv);
|
tools/power turbostat: show error on exec
When turbostat is run in one-shot command mode,
the parent takes the 'before' counter snapshot,
fork/exec/wait for the child to exit,
takes the 'after' counter snapshot,
and prints the results.
however, if the child fails to exec the command,
it immediately returns, without indicating that
anythign was wrong.
Add an error message showing that exec failed:
sudo turbostat sleeeep 4
...
turbostat: exec sleeeep: No such file or directory
...
Note that the parent will still print out the statistics,
because it can't tell the difference between the failed
exec and a command that is purposefully returning
the same status. Unfortunately, this may obscure the
error message. However, if the --out parameter is used,
the error message is evident on stderr.
Reported-by: Wendy Wang <wendy.wang@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-23 22:00:51 +00:00
|
|
|
err(errno, "exec %s", argv[0]);
|
2010-10-23 03:53:03 +00:00
|
|
|
} else {
|
|
|
|
|
|
|
|
/* parent */
|
2013-08-21 00:20:18 +00:00
|
|
|
if (child_pid == -1)
|
|
|
|
err(1, "fork");
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
signal(SIGINT, SIG_IGN);
|
|
|
|
signal(SIGQUIT, SIG_IGN);
|
2013-08-21 00:20:18 +00:00
|
|
|
if (waitpid(child_pid, &status, 0) == -1)
|
|
|
|
err(status, "waitpid");
|
2019-02-12 14:34:39 +00:00
|
|
|
|
|
|
|
if (WIFEXITED(status))
|
|
|
|
status = WEXITSTATUS(status);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
/*
|
|
|
|
* n.b. fork_it() does not check for errors from for_all_cpus()
|
|
|
|
* because re-starting is problematic when forking
|
|
|
|
*/
|
2017-02-15 03:07:52 +00:00
|
|
|
snapshot_proc_sysfs_files();
|
tools/power: turbostat v2 - re-write for efficiency
Measuring large profoundly-idle configurations
requires turbostat to be more lightweight.
Otherwise, the operation of turbostat itself
can interfere with the measurements.
This re-write makes turbostat topology aware.
Hardware is accessed in "topology order".
Redundant hardware accesses are deleted.
Redundant output is deleted.
Also, output is buffered and
local RDTSC use replaces remote MSR access for TSC.
From a feature point of view, the output
looks different since redundant figures are absent.
Also, there are now -c and -p options -- to restrict
output to the 1st thread in each core, and the 1st
thread in each package, respectively. This is helpful
to reduce output on big systems, where more detail
than the "-s" system summary is desired.
Finally, periodic mode output is now on stdout, not stderr.
Turbostat v2 is also slightly more robust in
handling run-time CPU online/offline events,
as it now checks the actual map of on-line cpus rather
than just the total number of on-line cpus.
Signed-off-by: Len Brown <len.brown@intel.com>
2012-06-04 04:56:40 +00:00
|
|
|
for_all_cpus(get_counters, ODD_COUNTERS);
|
2010-10-23 03:53:03 +00:00
|
|
|
gettimeofday(&tv_odd, (struct timezone *)NULL);
|
|
|
|
timersub(&tv_odd, &tv_even, &tv_delta);
|
tools/power turbostat: Gracefully handle ACPI S3
turbostat gives valid results across suspend to idle, aka freeze,
whether invoked in interval mode, or in command mode.
Indeed, this can be used to measure suspend to idle:
turbostat echo freeze > /sys/power/state
But this does not work across suspend to ACPI S3, because the
processor counters, including the TSC, are reset on resume.
Further, when turbostat detects a problem, it does't forgive
the hardware, and interval mode will print *'s from there on out.
Instead, upon detecting counters going backwards, simply
reset and start over.
Interval mode across ACPI S3: (observe TSC going backwards)
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 1 0.06 858 2294 0x0000000000000000
0 0 0.06 847 2294 0x0000002a254b98ac
1 1 0.06 878 2294 0x0000002a254efa3a
2 1 0.07 843 2294 0x0000002a2551df65
3 0 0.05 863 2294 0x0000002a2553fea2
turbostat: re-initialized with num_cpus 4
CPU Avg_MHz Busy% Bzy_MHz TSC_MHz MSR 0x010
- 2 0.20 849 2294 0x0000000000000000
0 2 0.26 856 2294 0x0000000449abb60d
1 2 0.20 844 2294 0x0000000449b087ec
2 2 0.21 850 2294 0x0000000449b35d5d
3 1 0.12 839 2294 0x0000000449b5fd5a
^C
Command mode across ACPI S3:
root@sharkbay:/home/lenb/turbostat-src# ./turbostat -M 0x10 sleep 10
./turbostat: Counter reset detected
14.196299 sec
Signed-off-by: Len Brown <len.brown@intel.com>
2016-04-23 00:31:46 +00:00
|
|
|
if (for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS))
|
|
|
|
fprintf(outf, "%s: Counter reset detected\n", progname);
|
|
|
|
else {
|
|
|
|
compute_average(EVEN_COUNTERS);
|
|
|
|
format_all_counters(EVEN_COUNTERS);
|
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);
|
|
|
|
|
|
|
|
flush_output_stderr();
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2012-11-01 04:08:19 +00:00
|
|
|
return status;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
2014-01-23 15:13:15 +00:00
|
|
|
int get_and_dump_counters(void)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
2017-02-15 03:07:52 +00:00
|
|
|
snapshot_proc_sysfs_files();
|
2014-01-23 15:13:15 +00:00
|
|
|
status = for_all_cpus(get_counters, ODD_COUNTERS);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
status = for_all_cpus(dump_counters, ODD_COUNTERS);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
2016-02-14 04:36:17 +00:00
|
|
|
flush_output_stdout();
|
2014-01-23 15:13:15 +00:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
void print_version() {
|
2019-03-21 03:23:25 +00:00
|
|
|
fprintf(outf, "turbostat version 19.03.20"
|
2015-02-10 06:56:38 +00:00
|
|
|
" - Len Brown <lenb@kernel.org>\n");
|
|
|
|
}
|
|
|
|
|
2017-02-08 07:41:51 +00:00
|
|
|
int add_counter(unsigned int msr_num, char *path, char *name,
|
|
|
|
unsigned int width, enum counter_scope scope,
|
2017-02-09 23:25:22 +00:00
|
|
|
enum counter_type type, enum counter_format format, int flags)
|
2016-12-23 04:57:55 +00:00
|
|
|
{
|
|
|
|
struct msr_counter *msrp;
|
|
|
|
|
|
|
|
msrp = calloc(1, sizeof(struct msr_counter));
|
|
|
|
if (msrp == NULL) {
|
|
|
|
perror("calloc");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
msrp->msr_num = msr_num;
|
|
|
|
strncpy(msrp->name, name, NAME_BYTES);
|
2017-02-08 07:41:51 +00:00
|
|
|
if (path)
|
|
|
|
strncpy(msrp->path, path, PATH_BYTES);
|
2016-12-23 04:57:55 +00:00
|
|
|
msrp->width = width;
|
|
|
|
msrp->type = type;
|
|
|
|
msrp->format = format;
|
2017-02-09 23:25:22 +00:00
|
|
|
msrp->flags = flags;
|
2016-12-23 04:57:55 +00:00
|
|
|
|
|
|
|
switch (scope) {
|
|
|
|
|
|
|
|
case SCOPE_CPU:
|
|
|
|
msrp->next = sys.tp;
|
|
|
|
sys.tp = msrp;
|
2017-02-10 03:22:13 +00:00
|
|
|
sys.added_thread_counters++;
|
2018-06-01 16:38:29 +00:00
|
|
|
if (sys.added_thread_counters > MAX_ADDED_THREAD_COUNTERS) {
|
2017-02-10 03:22:13 +00:00
|
|
|
fprintf(stderr, "exceeded max %d added thread counters\n",
|
|
|
|
MAX_ADDED_COUNTERS);
|
|
|
|
exit(-1);
|
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SCOPE_CORE:
|
|
|
|
msrp->next = sys.cp;
|
|
|
|
sys.cp = msrp;
|
2017-02-10 03:22:13 +00:00
|
|
|
sys.added_core_counters++;
|
|
|
|
if (sys.added_core_counters > MAX_ADDED_COUNTERS) {
|
|
|
|
fprintf(stderr, "exceeded max %d added core counters\n",
|
|
|
|
MAX_ADDED_COUNTERS);
|
|
|
|
exit(-1);
|
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SCOPE_PACKAGE:
|
|
|
|
msrp->next = sys.pp;
|
|
|
|
sys.pp = msrp;
|
2017-02-10 03:22:13 +00:00
|
|
|
sys.added_package_counters++;
|
|
|
|
if (sys.added_package_counters > MAX_ADDED_COUNTERS) {
|
|
|
|
fprintf(stderr, "exceeded max %d added package counters\n",
|
|
|
|
MAX_ADDED_COUNTERS);
|
|
|
|
exit(-1);
|
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void parse_add_command(char *add_command)
|
|
|
|
{
|
|
|
|
int msr_num = 0;
|
2017-02-08 07:41:51 +00:00
|
|
|
char *path = NULL;
|
2017-01-27 05:50:45 +00:00
|
|
|
char name_buffer[NAME_BYTES] = "";
|
2016-12-23 04:57:55 +00:00
|
|
|
int width = 64;
|
|
|
|
int fail = 0;
|
|
|
|
enum counter_scope scope = SCOPE_CPU;
|
|
|
|
enum counter_type type = COUNTER_CYCLES;
|
|
|
|
enum counter_format format = FORMAT_DELTA;
|
|
|
|
|
|
|
|
while (add_command) {
|
|
|
|
|
|
|
|
if (sscanf(add_command, "msr0x%x", &msr_num) == 1)
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
if (sscanf(add_command, "msr%d", &msr_num) == 1)
|
|
|
|
goto next;
|
|
|
|
|
2017-02-08 07:41:51 +00:00
|
|
|
if (*add_command == '/') {
|
|
|
|
path = add_command;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
2016-12-23 04:57:55 +00:00
|
|
|
if (sscanf(add_command, "u%d", &width) == 1) {
|
|
|
|
if ((width == 32) || (width == 64))
|
|
|
|
goto next;
|
|
|
|
width = 64;
|
|
|
|
}
|
|
|
|
if (!strncmp(add_command, "cpu", strlen("cpu"))) {
|
|
|
|
scope = SCOPE_CPU;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
if (!strncmp(add_command, "core", strlen("core"))) {
|
|
|
|
scope = SCOPE_CORE;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
if (!strncmp(add_command, "package", strlen("package"))) {
|
|
|
|
scope = SCOPE_PACKAGE;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
if (!strncmp(add_command, "cycles", strlen("cycles"))) {
|
|
|
|
type = COUNTER_CYCLES;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
if (!strncmp(add_command, "seconds", strlen("seconds"))) {
|
|
|
|
type = COUNTER_SECONDS;
|
|
|
|
goto next;
|
|
|
|
}
|
2017-02-09 23:25:22 +00:00
|
|
|
if (!strncmp(add_command, "usec", strlen("usec"))) {
|
|
|
|
type = COUNTER_USEC;
|
|
|
|
goto next;
|
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
if (!strncmp(add_command, "raw", strlen("raw"))) {
|
|
|
|
format = FORMAT_RAW;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
if (!strncmp(add_command, "delta", strlen("delta"))) {
|
|
|
|
format = FORMAT_DELTA;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
if (!strncmp(add_command, "percent", strlen("percent"))) {
|
|
|
|
format = FORMAT_PERCENT;
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sscanf(add_command, "%18s,%*s", name_buffer) == 1) { /* 18 < NAME_BYTES */
|
|
|
|
char *eos;
|
|
|
|
|
|
|
|
eos = strchr(name_buffer, ',');
|
|
|
|
if (eos)
|
|
|
|
*eos = '\0';
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
|
|
|
next:
|
|
|
|
add_command = strchr(add_command, ',');
|
2017-02-08 07:41:51 +00:00
|
|
|
if (add_command) {
|
|
|
|
*add_command = '\0';
|
2016-12-23 04:57:55 +00:00
|
|
|
add_command++;
|
2017-02-08 07:41:51 +00:00
|
|
|
}
|
2016-12-23 04:57:55 +00:00
|
|
|
|
|
|
|
}
|
2017-02-08 07:41:51 +00:00
|
|
|
if ((msr_num == 0) && (path == NULL)) {
|
|
|
|
fprintf(stderr, "--add: (msrDDD | msr0xXXX | /path_to_counter ) required\n");
|
2016-12-23 04:57:55 +00:00
|
|
|
fail++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* generate default column header */
|
|
|
|
if (*name_buffer == '\0') {
|
2017-02-23 23:10:27 +00:00
|
|
|
if (width == 32)
|
|
|
|
sprintf(name_buffer, "M0x%x%s", msr_num, format == FORMAT_PERCENT ? "%" : "");
|
|
|
|
else
|
|
|
|
sprintf(name_buffer, "M0X%x%s", msr_num, format == FORMAT_PERCENT ? "%" : "");
|
2016-12-23 04:57:55 +00:00
|
|
|
}
|
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
if (add_counter(msr_num, path, name_buffer, width, scope, type, format, 0))
|
2016-12-23 04:57:55 +00:00
|
|
|
fail++;
|
|
|
|
|
|
|
|
if (fail) {
|
|
|
|
help();
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
2017-02-09 23:25:22 +00:00
|
|
|
|
2017-02-22 04:21:13 +00:00
|
|
|
int is_deferred_skip(char *name)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < deferred_skip_index; ++i)
|
|
|
|
if (!strcmp(name, deferred_skip_names[i]))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
void probe_sysfs(void)
|
|
|
|
{
|
|
|
|
char path[64];
|
|
|
|
char name_buf[16];
|
|
|
|
FILE *input;
|
|
|
|
int state;
|
|
|
|
char *sp;
|
|
|
|
|
|
|
|
if (!DO_BIC(BIC_sysfs))
|
|
|
|
return;
|
|
|
|
|
2018-06-01 16:38:29 +00:00
|
|
|
for (state = 10; state >= 0; --state) {
|
2017-02-09 23:25:22 +00:00
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/cpuidle/state%d/name",
|
|
|
|
base_cpu, state);
|
|
|
|
input = fopen(path, "r");
|
|
|
|
if (input == NULL)
|
|
|
|
continue;
|
2019-03-21 03:01:03 +00:00
|
|
|
if (!fgets(name_buf, sizeof(name_buf), input))
|
|
|
|
err(1, "%s: failed to read file", path);
|
2017-02-09 23:25:22 +00:00
|
|
|
|
|
|
|
/* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */
|
|
|
|
sp = strchr(name_buf, '-');
|
|
|
|
if (!sp)
|
|
|
|
sp = strchrnul(name_buf, '\n');
|
|
|
|
*sp = '%';
|
|
|
|
*(sp + 1) = '\0';
|
|
|
|
|
|
|
|
fclose(input);
|
|
|
|
|
|
|
|
sprintf(path, "cpuidle/state%d/time", state);
|
|
|
|
|
2017-02-22 04:21:13 +00:00
|
|
|
if (is_deferred_skip(name_buf))
|
|
|
|
continue;
|
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
add_counter(0, path, name_buf, 64, SCOPE_CPU, COUNTER_USEC,
|
|
|
|
FORMAT_PERCENT, SYSFS_PERCPU);
|
|
|
|
}
|
|
|
|
|
2018-06-01 16:38:29 +00:00
|
|
|
for (state = 10; state >= 0; --state) {
|
2017-02-09 23:25:22 +00:00
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/cpuidle/state%d/name",
|
|
|
|
base_cpu, state);
|
|
|
|
input = fopen(path, "r");
|
|
|
|
if (input == NULL)
|
|
|
|
continue;
|
2019-03-21 03:01:03 +00:00
|
|
|
if (!fgets(name_buf, sizeof(name_buf), input))
|
|
|
|
err(1, "%s: failed to read file", path);
|
2017-02-09 23:25:22 +00:00
|
|
|
/* truncate "C1-HSW\n" to "C1", or truncate "C1\n" to "C1" */
|
|
|
|
sp = strchr(name_buf, '-');
|
|
|
|
if (!sp)
|
|
|
|
sp = strchrnul(name_buf, '\n');
|
|
|
|
*sp = '\0';
|
|
|
|
fclose(input);
|
|
|
|
|
|
|
|
sprintf(path, "cpuidle/state%d/usage", state);
|
|
|
|
|
2017-02-22 04:21:13 +00:00
|
|
|
if (is_deferred_skip(name_buf))
|
|
|
|
continue;
|
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
add_counter(0, path, name_buf, 64, SCOPE_CPU, COUNTER_ITEMS,
|
|
|
|
FORMAT_DELTA, SYSFS_PERCPU);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-11 04:54:15 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* parse cpuset with following syntax
|
|
|
|
* 1,2,4..6,8-10 and set bits in cpu_subset
|
|
|
|
*/
|
|
|
|
void parse_cpu_command(char *optarg)
|
|
|
|
{
|
|
|
|
unsigned int start, end;
|
|
|
|
char *next;
|
|
|
|
|
2017-02-22 03:33:42 +00:00
|
|
|
if (!strcmp(optarg, "core")) {
|
|
|
|
if (cpu_subset)
|
|
|
|
goto error;
|
|
|
|
show_core_only++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!strcmp(optarg, "package")) {
|
|
|
|
if (cpu_subset)
|
|
|
|
goto error;
|
|
|
|
show_pkg_only++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (show_core_only || show_pkg_only)
|
|
|
|
goto error;
|
|
|
|
|
2017-02-11 04:54:15 +00:00
|
|
|
cpu_subset = CPU_ALLOC(CPU_SUBSET_MAXCPUS);
|
|
|
|
if (cpu_subset == NULL)
|
|
|
|
err(3, "CPU_ALLOC");
|
|
|
|
cpu_subset_size = CPU_ALLOC_SIZE(CPU_SUBSET_MAXCPUS);
|
|
|
|
|
|
|
|
CPU_ZERO_S(cpu_subset_size, cpu_subset);
|
|
|
|
|
|
|
|
next = optarg;
|
|
|
|
|
|
|
|
while (next && *next) {
|
|
|
|
|
|
|
|
if (*next == '-') /* no negative cpu numbers */
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
start = strtoul(next, &next, 10);
|
|
|
|
|
|
|
|
if (start >= CPU_SUBSET_MAXCPUS)
|
|
|
|
goto error;
|
|
|
|
CPU_SET_S(start, cpu_subset_size, cpu_subset);
|
|
|
|
|
|
|
|
if (*next == '\0')
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (*next == ',') {
|
|
|
|
next += 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*next == '-') {
|
|
|
|
next += 1; /* start range */
|
|
|
|
} else if (*next == '.') {
|
|
|
|
next += 1;
|
|
|
|
if (*next == '.')
|
|
|
|
next += 1; /* start range */
|
|
|
|
else
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
end = strtoul(next, &next, 10);
|
|
|
|
if (end <= start)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
while (++start <= end) {
|
|
|
|
if (start >= CPU_SUBSET_MAXCPUS)
|
|
|
|
goto error;
|
|
|
|
CPU_SET_S(start, cpu_subset_size, cpu_subset);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*next == ',')
|
|
|
|
next += 1;
|
|
|
|
else if (*next != '\0')
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
2017-02-22 03:33:42 +00:00
|
|
|
fprintf(stderr, "\"--cpu %s\" malformed\n", optarg);
|
|
|
|
help();
|
2017-02-11 04:54:15 +00:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2017-02-10 05:25:41 +00:00
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
void cmdline(int argc, char **argv)
|
|
|
|
{
|
|
|
|
int opt;
|
2015-02-10 06:56:38 +00:00
|
|
|
int option_index = 0;
|
|
|
|
static struct option long_options[] = {
|
2016-12-23 04:57:55 +00:00
|
|
|
{"add", required_argument, 0, 'a'},
|
2017-02-11 04:54:15 +00:00
|
|
|
{"cpu", required_argument, 0, 'c'},
|
2015-02-10 06:56:38 +00:00
|
|
|
{"Dump", no_argument, 0, 'D'},
|
2017-01-21 07:26:00 +00:00
|
|
|
{"debug", no_argument, 0, 'd'}, /* internal, not documented */
|
2017-10-17 19:42:56 +00:00
|
|
|
{"enable", required_argument, 0, 'e'},
|
2015-02-10 06:56:38 +00:00
|
|
|
{"interval", required_argument, 0, 'i'},
|
2018-04-26 00:41:03 +00:00
|
|
|
{"num_iterations", required_argument, 0, 'n'},
|
2015-02-10 06:56:38 +00:00
|
|
|
{"help", no_argument, 0, 'h'},
|
2017-02-10 05:25:41 +00:00
|
|
|
{"hide", required_argument, 0, 'H'}, // meh, -h taken by --help
|
2015-02-10 06:56:38 +00:00
|
|
|
{"Joules", no_argument, 0, 'J'},
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
{"list", no_argument, 0, 'l'},
|
2016-02-14 04:36:17 +00:00
|
|
|
{"out", required_argument, 0, 'o'},
|
2017-01-21 07:26:00 +00:00
|
|
|
{"quiet", no_argument, 0, 'q'},
|
2017-02-10 05:25:41 +00:00
|
|
|
{"show", required_argument, 0, 's'},
|
2015-02-10 06:56:38 +00:00
|
|
|
{"Summary", no_argument, 0, 'S'},
|
|
|
|
{"TCC", required_argument, 0, 'T'},
|
|
|
|
{"version", no_argument, 0, 'v' },
|
|
|
|
{0, 0, 0, 0 }
|
|
|
|
};
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
progname = argv[0];
|
|
|
|
|
2018-04-26 00:41:03 +00:00
|
|
|
while ((opt = getopt_long_only(argc, argv, "+C:c:Dde:hi:Jn:o:qST:v",
|
2015-02-10 06:56:38 +00:00
|
|
|
long_options, &option_index)) != -1) {
|
2010-10-23 03:53:03 +00:00
|
|
|
switch (opt) {
|
2016-12-23 04:57:55 +00:00
|
|
|
case 'a':
|
|
|
|
parse_add_command(optarg);
|
|
|
|
break;
|
2017-02-11 04:54:15 +00:00
|
|
|
case 'c':
|
|
|
|
parse_cpu_command(optarg);
|
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'D':
|
2014-01-23 15:13:15 +00:00
|
|
|
dump_only++;
|
|
|
|
break;
|
2017-10-17 19:42:56 +00:00
|
|
|
case 'e':
|
|
|
|
/* --enable specified counter */
|
2018-06-06 21:44:48 +00:00
|
|
|
bic_enabled = bic_enabled | bic_lookup(optarg, SHOW_LIST);
|
2017-10-17 19:42:56 +00:00
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'd':
|
|
|
|
debug++;
|
2017-10-17 19:42:56 +00:00
|
|
|
ENABLE_BIC(BIC_DISABLED_BY_DEFAULT);
|
2010-10-23 03:53:03 +00:00
|
|
|
break;
|
2017-02-10 05:25:41 +00:00
|
|
|
case 'H':
|
2017-10-17 19:42:56 +00:00
|
|
|
/*
|
|
|
|
* --hide: do not show those specified
|
|
|
|
* multiple invocations simply clear more bits in enabled mask
|
|
|
|
*/
|
|
|
|
bic_enabled &= ~bic_lookup(optarg, HIDE_LIST);
|
2017-02-10 05:25:41 +00:00
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'h':
|
|
|
|
default:
|
|
|
|
help();
|
|
|
|
exit(1);
|
2010-10-23 03:53:03 +00:00
|
|
|
case 'i':
|
2016-02-13 03:44:48 +00:00
|
|
|
{
|
|
|
|
double interval = strtod(optarg, NULL);
|
|
|
|
|
|
|
|
if (interval < 0.001) {
|
2016-02-14 04:36:17 +00:00
|
|
|
fprintf(outf, "interval %f seconds is too small\n",
|
2016-02-13 03:44:48 +00:00
|
|
|
interval);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
|
2017-10-04 12:01:47 +00:00
|
|
|
interval_tv.tv_sec = interval_ts.tv_sec = interval;
|
2017-07-19 23:28:37 +00:00
|
|
|
interval_tv.tv_usec = (interval - interval_tv.tv_sec) * 1000000;
|
2017-10-04 12:01:47 +00:00
|
|
|
interval_ts.tv_nsec = (interval - interval_ts.tv_sec) * 1000000000;
|
2016-02-13 03:44:48 +00:00
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'J':
|
|
|
|
rapl_joules++;
|
2012-09-22 05:25:08 +00:00
|
|
|
break;
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
case 'l':
|
2017-10-17 19:42:56 +00:00
|
|
|
ENABLE_BIC(BIC_DISABLED_BY_DEFAULT);
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
list_header_only++;
|
|
|
|
quiet++;
|
|
|
|
break;
|
2016-02-14 04:36:17 +00:00
|
|
|
case 'o':
|
|
|
|
outf = fopen_or_die(optarg, "w");
|
|
|
|
break;
|
2017-01-21 07:26:00 +00:00
|
|
|
case 'q':
|
|
|
|
quiet = 1;
|
|
|
|
break;
|
2018-04-26 00:41:03 +00:00
|
|
|
case 'n':
|
|
|
|
num_iterations = strtod(optarg, NULL);
|
|
|
|
|
|
|
|
if (num_iterations <= 0) {
|
|
|
|
fprintf(outf, "iterations %d should be positive number\n",
|
|
|
|
num_iterations);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
break;
|
2017-02-10 05:25:41 +00:00
|
|
|
case 's':
|
2017-10-17 19:42:56 +00:00
|
|
|
/*
|
|
|
|
* --show: show only those specified
|
|
|
|
* The 1st invocation will clear and replace the enabled mask
|
|
|
|
* subsequent invocations can add to it.
|
|
|
|
*/
|
|
|
|
if (shown == 0)
|
|
|
|
bic_enabled = bic_lookup(optarg, SHOW_LIST);
|
|
|
|
else
|
|
|
|
bic_enabled |= bic_lookup(optarg, SHOW_LIST);
|
|
|
|
shown = 1;
|
2017-02-10 05:25:41 +00:00
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'S':
|
|
|
|
summary_only++;
|
tools/power turbostat: v3.0: monitor Watts and Temperature
Show power in Watts and temperature in Celsius
when hardware support is present.
Intel's Sandy Bridge and Ivy Bridge processor generations support RAPL
(Run-Time-Average-Power-Limiting). Per the Intel SDM
(Intel® 64 and IA-32 Architectures Software Developer Manual)
RAPL provides hardware energy counters and power control MSRs
(Model Specific Registers). RAPL MSRs are designed primarily
as a method to implement power capping. However, they are useful
for monitoring system power whether or not power capping is used.
In addition, Turbostat now shows temperature from DTS
(Digital Thermal Sensor) and PTM (Package Thermal Monitor) hardware,
if present.
As before, turbostat reads MSRs, and never writes MSRs.
New columns are present in turbostat output:
The Pkg_W column shows Watts for each package (socket) in the system.
On multi-socket systems, the system summary on the 1st row shows the sum
for all sockets together.
The Cor_W column shows Watts due to processors cores.
Note that Core_W is included in Pkg_W.
The optional GFX_W column shows Watts due to the graphics "un-core".
Note that GFX_W is included in Pkg_W.
The optional RAM_W column on server processors shows Watts due to DRAM DIMMS.
As DRAM DIMMs are outside the processor package, RAM_W is not included in Pkg_W.
The optional PKG_% and RAM_% columns on server processors shows the % of time
in the measurement interval that RAPL power limiting is in effect on the
package and on DRAM.
Note that the RAPL energy counters have some limitations.
First, hardware updates the counters about once every milli-second.
This is fine for typical turbostat measurement intervals > 1 sec.
However, when turbostat is used to measure events that approach
1ms, the counters are less useful.
Second, the 32-bit energy counters are subject to wrapping.
For example, a counter incrementing 15 micro-Joule units
on a 130 Watt TDP server processor could (in theory)
roll over in about 9 minutes. Turbostat detects and handles
up to 1 counter overflow per measurement interval.
But when the measurement interval exceeds the guaranteed
counter range, we can't detect if more than 1 overflow occured.
So in this case turbostat indicates that the results are
in question by replacing the fractional part of the Watts
in the output with "**":
Pkg_W Cor_W GFX_W
3** 0** 0**
Third, the RAPL counters are energy (Joule) counters -- they sum up
weighted events in the package to estimate energy consumed. They are
not analong power (Watt) meters. In practice, they tend to under-count
because they don't cover every possible use of energy in the package.
The accuracy of the RAPL counters will vary between product generations,
and between SKU's in the same product generation, and with temperature.
turbostat's -v (verbose) option now displays more power and thermal configuration
information -- as shown on the turbostat.8 manual page.
For example, it now displays the Package and DRAM Thermal Design Power (TDP):
cpu0: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu0: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
cpu8: MSR_PKG_POWER_INFO: 0x2f064001980410 (130 W TDP, RAPL 51 - 200 W, 0.045898 sec.)
cpu8: MSR_DRAM_POWER_INFO,: 0x28025800780118 (35 W TDP, RAPL 15 - 75 W, 0.039062 sec.)
Signed-off-by: Len Brown <len.brown@intel.com>
2012-11-08 05:48:57 +00:00
|
|
|
break;
|
|
|
|
case 'T':
|
|
|
|
tcc_activation_temp_override = atoi(optarg);
|
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'v':
|
|
|
|
print_version();
|
|
|
|
exit(0);
|
2013-12-16 18:23:41 +00:00
|
|
|
break;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2016-02-14 04:36:17 +00:00
|
|
|
outf = stderr;
|
2010-10-23 03:53:03 +00:00
|
|
|
cmdline(argc, argv);
|
|
|
|
|
2017-01-21 07:26:00 +00:00
|
|
|
if (!quiet)
|
2015-02-10 06:56:38 +00:00
|
|
|
print_version();
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2017-02-09 23:25:22 +00:00
|
|
|
probe_sysfs();
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
turbostat_init();
|
|
|
|
|
2014-01-23 15:13:15 +00:00
|
|
|
/* dump counters and exit */
|
|
|
|
if (dump_only)
|
|
|
|
return get_and_dump_counters();
|
|
|
|
|
tools/power turbostat: Add --list option to show available header names
It is handy to know the list of column header names,
so that they can be used with --add and --skip
The new --list option shows them:
sudo ./turbostat --list --hide sysfs
,Core,CPU,Avg_MHz,Busy%,Bzy_MHz,TSC_MHz,IRQ,SMI,CPU%c1,CPU%c3,CPU%c6,CPU%c7,CoreTmp,PkgTmp,GFX%rc6,GFXMHz,PkgWatt,CorWatt,GFXWatt
Signed-off-by: Len Brown <len.brown@intel.com>
2017-02-15 22:15:11 +00:00
|
|
|
/* list header and exit */
|
|
|
|
if (list_header_only) {
|
|
|
|
print_header(",");
|
|
|
|
flush_output_stdout();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
/*
|
|
|
|
* if any params left, it must be a command to fork
|
|
|
|
*/
|
|
|
|
if (argc - optind)
|
|
|
|
return fork_it(argv + optind);
|
|
|
|
else
|
|
|
|
turbostat_loop();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|