2010-10-23 03:53:03 +00:00
|
|
|
/*
|
|
|
|
|
* turbostat -- show CPU frequency and C-state residency
|
|
|
|
|
* on modern Intel turbo-capable processors.
|
|
|
|
|
*
|
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>
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
|
* version 2, as published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
|
* more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
|
* this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
|
* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
|
*/
|
|
|
|
|
|
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
|
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>
|
|
|
|
|
#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>
|
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>
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
|
char *proc_stat = "/proc/stat";
|
2015-02-10 06:56:38 +00:00
|
|
|
unsigned int interval_sec = 5;
|
|
|
|
|
unsigned int debug;
|
|
|
|
|
unsigned int rapl_joules;
|
|
|
|
|
unsigned int summary_only;
|
|
|
|
|
unsigned int dump_only;
|
2010-10-23 03:53:03 +00:00
|
|
|
unsigned int skip_c0;
|
|
|
|
|
unsigned int skip_c1;
|
|
|
|
|
unsigned int do_nhm_cstates;
|
|
|
|
|
unsigned int do_snb_cstates;
|
2015-02-10 04:39:45 +00:00
|
|
|
unsigned int do_pc2;
|
|
|
|
|
unsigned int do_pc3;
|
|
|
|
|
unsigned int do_pc6;
|
|
|
|
|
unsigned int do_pc7;
|
2012-11-21 13:22:43 +00:00
|
|
|
unsigned int do_c8_c9_c10;
|
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;
|
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;
|
|
|
|
|
unsigned int has_invariant_tsc;
|
2015-01-23 05:12:33 +00:00
|
|
|
unsigned int do_nhm_platform_info;
|
|
|
|
|
unsigned int do_nhm_turbo_ratio_limit;
|
2012-09-21 04:01:31 +00:00
|
|
|
unsigned int do_ivt_turbo_ratio_limit;
|
2012-09-22 03:45:46 +00:00
|
|
|
unsigned int extra_msr_offset32;
|
|
|
|
|
unsigned int extra_msr_offset64;
|
2012-09-22 05:25:08 +00:00
|
|
|
unsigned int extra_delta_offset32;
|
|
|
|
|
unsigned int extra_delta_offset64;
|
2013-02-10 22:19:24 +00:00
|
|
|
int do_smi;
|
2010-10-23 03:53:03 +00:00
|
|
|
double bclk;
|
|
|
|
|
unsigned int show_pkg;
|
|
|
|
|
unsigned int show_core;
|
|
|
|
|
unsigned int show_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
|
|
|
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;
|
|
|
|
|
unsigned int tcc_activation_temp;
|
|
|
|
|
unsigned int tcc_activation_temp_override;
|
|
|
|
|
double rapl_power_units, rapl_energy_units, rapl_time_units;
|
|
|
|
|
double rapl_joule_counter_range;
|
2014-08-15 06:39:52 +00:00
|
|
|
unsigned int do_core_perf_limit_reasons;
|
|
|
|
|
unsigned int do_gfx_perf_limit_reasons;
|
|
|
|
|
unsigned int do_ring_perf_limit_reasons;
|
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 */
|
|
|
|
|
/* 0x61c MSR_DRAM_POWER_INFO */
|
|
|
|
|
#define RAPL_DRAM_PERF_STATUS (1 << 4)
|
|
|
|
|
/* 0x61b MSR_DRAM_PERF_STATUS */
|
|
|
|
|
|
|
|
|
|
#define RAPL_CORES (1 << 5)
|
|
|
|
|
/* 0x638 MSR_PP0_POWER_LIMIT */
|
|
|
|
|
/* 0x639 MSR_PP0_ENERGY_STATUS */
|
|
|
|
|
#define RAPL_CORE_POLICY (1 << 6)
|
|
|
|
|
/* 0x63a MSR_PP0_POLICY */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define RAPL_GFX (1 << 7)
|
|
|
|
|
/* 0x640 MSR_PP1_POWER_LIMIT */
|
|
|
|
|
/* 0x641 MSR_PP1_ENERGY_STATUS */
|
|
|
|
|
/* 0x642 MSR_PP1_POLICY */
|
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
|
|
|
|
|
|
|
|
|
|
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
|
int aperf_mperf_unstable;
|
|
|
|
|
int backwards_count;
|
|
|
|
|
char *progname;
|
|
|
|
|
|
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_set_t *cpu_present_set, *cpu_affinity_set;
|
|
|
|
|
size_t cpu_present_setsize, cpu_affinity_setsize;
|
|
|
|
|
|
|
|
|
|
struct thread_data {
|
|
|
|
|
unsigned long long tsc;
|
|
|
|
|
unsigned long long aperf;
|
|
|
|
|
unsigned long long mperf;
|
2013-11-09 05:30:16 +00:00
|
|
|
unsigned long long c1;
|
2012-09-22 03:45:46 +00:00
|
|
|
unsigned long long extra_msr64;
|
2012-09-22 05:25:08 +00:00
|
|
|
unsigned long long extra_delta64;
|
|
|
|
|
unsigned long long extra_msr32;
|
|
|
|
|
unsigned long long extra_delta32;
|
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;
|
|
|
|
|
unsigned int flags;
|
|
|
|
|
#define CPU_IS_FIRST_THREAD_IN_CORE 0x2
|
|
|
|
|
#define CPU_IS_FIRST_CORE_IN_PACKAGE 0x4
|
|
|
|
|
} *thread_even, *thread_odd;
|
|
|
|
|
|
|
|
|
|
struct core_data {
|
|
|
|
|
unsigned long long c3;
|
|
|
|
|
unsigned long long c6;
|
|
|
|
|
unsigned long long 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
|
|
|
unsigned int core_temp_c;
|
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;
|
|
|
|
|
} *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;
|
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;
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
|
#define GET_THREAD(thread_base, thread_no, core_no, pkg_no) \
|
|
|
|
|
(thread_base + (pkg_no) * topo.num_cores_per_pkg * \
|
|
|
|
|
topo.num_threads_per_core + \
|
|
|
|
|
(core_no) * topo.num_threads_per_core + (thread_no))
|
|
|
|
|
#define GET_CORE(core_base, core_no, pkg_no) \
|
|
|
|
|
(core_base + (pkg_no) * topo.num_cores_per_pkg + (core_no))
|
|
|
|
|
#define GET_PKG(pkg_base, pkg_no) (pkg_base + pkg_no)
|
|
|
|
|
|
|
|
|
|
struct system_summary {
|
|
|
|
|
struct thread_data threads;
|
|
|
|
|
struct core_data cores;
|
|
|
|
|
struct pkg_data packages;
|
|
|
|
|
} sum, average;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct topo_params {
|
|
|
|
|
int num_packages;
|
|
|
|
|
int num_cpus;
|
|
|
|
|
int num_cores;
|
|
|
|
|
int max_cpu_num;
|
|
|
|
|
int num_cores_per_pkg;
|
|
|
|
|
int num_threads_per_core;
|
|
|
|
|
} topo;
|
|
|
|
|
|
|
|
|
|
struct timeval tv_even, tv_odd, tv_delta;
|
|
|
|
|
|
|
|
|
|
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
|
|
|
{
|
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, pkg_no, core_no, thread_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) {
|
|
|
|
|
for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
|
|
|
|
|
for (thread_no = 0; thread_no <
|
|
|
|
|
topo.num_threads_per_core; ++thread_no) {
|
|
|
|
|
struct thread_data *t;
|
|
|
|
|
struct core_data *c;
|
|
|
|
|
struct pkg_data *p;
|
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
|
|
|
t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
|
|
|
|
|
|
|
|
|
|
if (cpu_is_not_present(t->cpu_id))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
c = GET_CORE(core_base, core_no, pkg_no);
|
|
|
|
|
p = GET_PKG(pkg_base, pkg_no);
|
|
|
|
|
|
|
|
|
|
retval = func(t, c, p);
|
|
|
|
|
if (retval)
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-30 02:19:58 +00:00
|
|
|
int get_msr(int cpu, off_t offset, unsigned long long *msr)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
|
|
|
|
ssize_t retval;
|
|
|
|
|
char pathname[32];
|
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
2012-03-30 02:19:58 +00:00
|
|
|
retval = pread(fd, msr, sizeof *msr, offset);
|
2010-10-23 03:53:03 +00:00
|
|
|
close(fd);
|
2012-03-30 02:19:58 +00:00
|
|
|
|
2014-08-15 04:36:50 +00:00
|
|
|
if (retval != sizeof *msr)
|
|
|
|
|
err(-1, "%s offset 0x%llx read failed", pathname, (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
|
|
|
/*
|
|
|
|
|
* Example Format w/ field column widths:
|
|
|
|
|
*
|
2014-08-15 01:22:13 +00:00
|
|
|
* Package Core CPU Avg_MHz Bzy_MHz TSC_MHz SMI %Busy CPU_%c1 CPU_%c3 CPU_%c6 CPU_%c7 CoreTmp PkgTmp Pkg%pc2 Pkg%pc3 Pkg%pc6 Pkg%pc7 PkgWatt CorWatt GFXWatt
|
|
|
|
|
* 123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678
|
2014-02-06 05:55:19 +00:00
|
|
|
*/
|
|
|
|
|
|
2011-02-11 04:36:34 +00:00
|
|
|
void print_header(void)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
|
|
|
|
if (show_pkg)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Package");
|
2010-10-23 03:53:03 +00:00
|
|
|
if (show_core)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Core");
|
2010-10-23 03:53:03 +00:00
|
|
|
if (show_cpu)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " CPU");
|
2014-02-06 05:55:19 +00:00
|
|
|
if (has_aperf)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Avg_MHz");
|
2015-01-23 05:12:33 +00:00
|
|
|
if (has_aperf)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " %%Busy");
|
2010-10-23 03:53:03 +00:00
|
|
|
if (has_aperf)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Bzy_MHz");
|
|
|
|
|
outp += sprintf(outp, " TSC_MHz");
|
2013-02-10 22:19:24 +00:00
|
|
|
if (do_smi)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " SMI");
|
2012-09-22 05:25:08 +00:00
|
|
|
if (extra_delta_offset32)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " count 0x%03X", extra_delta_offset32);
|
2012-09-22 05:25:08 +00:00
|
|
|
if (extra_delta_offset64)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " COUNT 0x%03X", extra_delta_offset64);
|
2012-09-22 03:45:46 +00:00
|
|
|
if (extra_msr_offset32)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " MSR 0x%03X", extra_msr_offset32);
|
2012-09-22 03:45:46 +00:00
|
|
|
if (extra_msr_offset64)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " MSR 0x%03X", extra_msr_offset64);
|
2010-10-23 03:53:03 +00:00
|
|
|
if (do_nhm_cstates)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " CPU%%c1");
|
2013-11-09 05:30:16 +00:00
|
|
|
if (do_nhm_cstates && !do_slm_cstates)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " CPU%%c3");
|
2010-10-23 03:53:03 +00:00
|
|
|
if (do_nhm_cstates)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " CPU%%c6");
|
2010-10-23 03:53:03 +00:00
|
|
|
if (do_snb_cstates)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " CPU%%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
|
|
|
|
|
|
|
|
if (do_dts)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " 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 (do_ptm)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " 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
|
|
|
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc2)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Pkg%%pc2");
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc3)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Pkg%%pc3");
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc6)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Pkg%%pc6");
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc7)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Pkg%%pc7");
|
2012-11-21 13:22:43 +00:00
|
|
|
if (do_c8_c9_c10) {
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Pkg%%pc8");
|
|
|
|
|
outp += sprintf(outp, " Pkg%%pc9");
|
|
|
|
|
outp += sprintf(outp, " Pk%%pc10");
|
2012-11-21 13:22:43 +00:00
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl && !rapl_joules) {
|
|
|
|
|
if (do_rapl & RAPL_PKG)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " PkgWatt");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_CORES)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " CorWatt");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_GFX)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " GFXWatt");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_DRAM)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " RAMWatt");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_PKG_PERF_STATUS)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " PKG_%%");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_DRAM_PERF_STATUS)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " RAM_%%");
|
2015-01-23 05:12:33 +00:00
|
|
|
} else if (do_rapl && rapl_joules) {
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_PKG)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Pkg_J");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_CORES)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " Cor_J");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_GFX)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " GFX_J");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_DRAM)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " RAM_W");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_PKG_PERF_STATUS)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " PKG_%%");
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_DRAM_PERF_STATUS)
|
2014-08-15 01:22:13 +00:00
|
|
|
outp += sprintf(outp, " RAM_%%");
|
|
|
|
|
outp += sprintf(outp, " time");
|
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-16 18:23:41 +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
|
|
|
{
|
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);
|
|
|
|
|
outp += sprintf(outp, "msr0x%x: %08llX\n",
|
2012-09-22 05:25:08 +00:00
|
|
|
extra_delta_offset32, t->extra_delta32);
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "msr0x%x: %016llX\n",
|
2012-09-22 05:25:08 +00:00
|
|
|
extra_delta_offset64, t->extra_delta64);
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "msr0x%x: %08llX\n",
|
2012-09-22 03:45:46 +00:00
|
|
|
extra_msr_offset32, t->extra_msr32);
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "msr0x%x: %016llX\n",
|
2012-09-22 03:45:46 +00:00
|
|
|
extra_msr_offset64, t->extra_msr64);
|
2013-02-10 22:19:24 +00:00
|
|
|
if (do_smi)
|
2014-01-23 15:13:15 +00:00
|
|
|
outp += sprintf(outp, "SMI: %08X\n", t->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
|
|
|
}
|
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);
|
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);
|
|
|
|
|
outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc3)
|
|
|
|
|
outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
|
|
|
|
|
if (do_pc6)
|
|
|
|
|
outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
|
|
|
|
|
if (do_pc7)
|
|
|
|
|
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);
|
|
|
|
|
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);
|
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
|
|
|
{
|
|
|
|
|
double interval_float;
|
2014-02-06 05:55:19 +00:00
|
|
|
char *fmt8;
|
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;
|
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.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
|
|
|
/* topo columns, print blanks on 1st (average) line */
|
|
|
|
|
if (t == &average.threads) {
|
2010-10-23 03:53:03 +00:00
|
|
|
if (show_pkg)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, " -");
|
2010-10-23 03:53:03 +00:00
|
|
|
if (show_core)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, " -");
|
2010-10-23 03:53:03 +00:00
|
|
|
if (show_cpu)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, " -");
|
2010-10-23 03:53:03 +00:00
|
|
|
} else {
|
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 (show_pkg) {
|
|
|
|
|
if (p)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8d", 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
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, " -");
|
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 (show_core) {
|
|
|
|
|
if (c)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8d", 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
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, " -");
|
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
|
|
|
if (show_cpu)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8d", t->cpu_id);
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
2014-02-06 05:55:19 +00:00
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
/* Avg_MHz */
|
2014-02-06 05:55:19 +00:00
|
|
|
if (has_aperf)
|
|
|
|
|
outp += sprintf(outp, "%8.0f",
|
|
|
|
|
1.0 / units * t->aperf / interval_float);
|
|
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
/* %Busy */
|
|
|
|
|
if (has_aperf) {
|
2010-10-23 03:53:03 +00:00
|
|
|
if (!skip_c0)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * t->mperf/t->tsc);
|
2010-10-23 03:53:03 +00:00
|
|
|
else
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "********");
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
/* Bzy_MHz */
|
2014-02-06 05:55:19 +00:00
|
|
|
if (has_aperf)
|
|
|
|
|
outp += sprintf(outp, "%8.0f",
|
|
|
|
|
1.0 * t->tsc / units * t->aperf / t->mperf / interval_float);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
/* TSC_MHz */
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.0f", 1.0 * t->tsc/units/interval_float);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2013-02-10 22:19:24 +00:00
|
|
|
/* SMI */
|
|
|
|
|
if (do_smi)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8d", t->smi_count);
|
2013-02-10 22:19:24 +00:00
|
|
|
|
2012-09-22 05:25:08 +00:00
|
|
|
/* delta */
|
|
|
|
|
if (extra_delta_offset32)
|
|
|
|
|
outp += sprintf(outp, " %11llu", t->extra_delta32);
|
|
|
|
|
|
|
|
|
|
/* DELTA */
|
|
|
|
|
if (extra_delta_offset64)
|
|
|
|
|
outp += sprintf(outp, " %11llu", t->extra_delta64);
|
2012-09-22 03:45:46 +00:00
|
|
|
/* msr */
|
|
|
|
|
if (extra_msr_offset32)
|
2012-09-22 05:25:08 +00:00
|
|
|
outp += sprintf(outp, " 0x%08llx", t->extra_msr32);
|
2012-09-22 03:45:46 +00:00
|
|
|
|
2012-09-22 02:56:06 +00:00
|
|
|
/* MSR */
|
2012-09-22 03:45:46 +00:00
|
|
|
if (extra_msr_offset64)
|
|
|
|
|
outp += sprintf(outp, " 0x%016llx", t->extra_msr64);
|
2012-09-22 02:56:06 +00:00
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
if (do_nhm_cstates) {
|
|
|
|
|
if (!skip_c1)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * t->c1/t->tsc);
|
2010-10-23 03:53:03 +00:00
|
|
|
else
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "********");
|
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
|
|
|
|
|
|
|
|
/* print per-core data only for 1st thread in core */
|
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
|
|
|
|
|
goto done;
|
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
if (do_nhm_cstates && !do_slm_cstates)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * c->c3/t->tsc);
|
2010-10-23 03:53:03 +00:00
|
|
|
if (do_nhm_cstates)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * c->c6/t->tsc);
|
2010-10-23 03:53:03 +00:00
|
|
|
if (do_snb_cstates)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * c->c7/t->tsc);
|
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
|
|
|
if (do_dts)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8d", 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
|
|
|
|
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;
|
|
|
|
|
|
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_ptm)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8d", 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
|
|
|
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc2)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * p->pc2/t->tsc);
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc3)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * p->pc3/t->tsc);
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc6)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * p->pc6/t->tsc);
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc7)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * p->pc7/t->tsc);
|
2012-11-21 13:22:43 +00:00
|
|
|
if (do_c8_c9_c10) {
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * p->pc8/t->tsc);
|
|
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * p->pc9/t->tsc);
|
|
|
|
|
outp += sprintf(outp, "%8.2f", 100.0 * p->pc10/t->tsc);
|
2012-11-21 13:22:43 +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
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If measurement interval exceeds minimum RAPL Joule Counter range,
|
|
|
|
|
* indicate that results are suspect by printing "**" in fraction place.
|
|
|
|
|
*/
|
2014-02-06 05:55:19 +00:00
|
|
|
if (interval_float < rapl_joule_counter_range)
|
|
|
|
|
fmt8 = "%8.2f";
|
|
|
|
|
else
|
|
|
|
|
fmt8 = " %6.0f**";
|
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-16 18:23:41 +00:00
|
|
|
if (do_rapl && !rapl_joules) {
|
|
|
|
|
if (do_rapl & RAPL_PKG)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8, p->energy_pkg * rapl_energy_units / interval_float);
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_CORES)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8, p->energy_cores * rapl_energy_units / interval_float);
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_GFX)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8, p->energy_gfx * rapl_energy_units / interval_float);
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_DRAM)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8, p->energy_dram * rapl_energy_units / interval_float);
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_PKG_PERF_STATUS)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_DRAM_PERF_STATUS)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
|
2015-01-23 05:12:33 +00:00
|
|
|
} else if (do_rapl && rapl_joules) {
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_PKG)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8,
|
2013-12-16 18:23:41 +00:00
|
|
|
p->energy_pkg * rapl_energy_units);
|
|
|
|
|
if (do_rapl & RAPL_CORES)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8,
|
2013-12-16 18:23:41 +00:00
|
|
|
p->energy_cores * rapl_energy_units);
|
|
|
|
|
if (do_rapl & RAPL_GFX)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8,
|
2013-12-16 18:23:41 +00:00
|
|
|
p->energy_gfx * rapl_energy_units);
|
|
|
|
|
if (do_rapl & RAPL_DRAM)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8,
|
2013-12-16 18:23:41 +00:00
|
|
|
p->energy_dram * rapl_energy_units);
|
|
|
|
|
if (do_rapl & RAPL_PKG_PERF_STATUS)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
|
2013-12-16 18:23:41 +00:00
|
|
|
if (do_rapl & RAPL_DRAM_PERF_STATUS)
|
2014-02-06 05:55:19 +00:00
|
|
|
outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
|
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
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
outp += sprintf(outp, fmt8, interval_float);
|
2013-12-16 18:23:41 +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:
|
|
|
|
|
outp += sprintf(outp, "\n");
|
|
|
|
|
|
|
|
|
|
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
|
|
|
void flush_stdout()
|
|
|
|
|
{
|
|
|
|
|
fputs(output_buffer, stdout);
|
2012-11-30 06:01:40 +00:00
|
|
|
fflush(stdout);
|
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 flush_stderr()
|
|
|
|
|
{
|
|
|
|
|
fputs(output_buffer, stderr);
|
|
|
|
|
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)
|
|
|
|
|
print_header();
|
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 (topo.num_cpus > 1)
|
|
|
|
|
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 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_package(struct pkg_data *new, struct pkg_data *old)
|
|
|
|
|
{
|
|
|
|
|
old->pc2 = new->pc2 - old->pc2;
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc3)
|
|
|
|
|
old->pc3 = new->pc3 - old->pc3;
|
|
|
|
|
if (do_pc6)
|
|
|
|
|
old->pc6 = new->pc6 - old->pc6;
|
|
|
|
|
if (do_pc7)
|
|
|
|
|
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;
|
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;
|
|
|
|
|
|
|
|
|
|
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 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
|
|
|
{
|
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;
|
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 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_thread(struct thread_data *new, struct thread_data *old,
|
|
|
|
|
struct core_data *core_delta)
|
|
|
|
|
{
|
|
|
|
|
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
|
|
|
|
2015-01-23 06:33:58 +00:00
|
|
|
if (has_aperf) {
|
|
|
|
|
if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
|
|
|
|
|
old->aperf = new->aperf - old->aperf;
|
|
|
|
|
old->mperf = new->mperf - old->mperf;
|
|
|
|
|
} else {
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-01-23 06:33:58 +00:00
|
|
|
if (!aperf_mperf_unstable) {
|
|
|
|
|
fprintf(stderr, "%s: APERF or MPERF went backwards *\n", progname);
|
|
|
|
|
fprintf(stderr, "* Frequency results do not cover entire interval *\n");
|
|
|
|
|
fprintf(stderr, "* fix this by running Linux-2.6.30 or later *\n");
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-01-23 06:33:58 +00:00
|
|
|
aperf_mperf_unstable = 1;
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* mperf delta is likely a huge "positive" number
|
|
|
|
|
* can not use it for calculating c0 time
|
|
|
|
|
*/
|
|
|
|
|
skip_c0 = 1;
|
|
|
|
|
skip_c1 = 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.
|
|
|
|
|
*/
|
|
|
|
|
if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
|
|
|
|
|
old->c1 = 0;
|
|
|
|
|
else {
|
|
|
|
|
/* normal case, derive c1 */
|
|
|
|
|
old->c1 = old->tsc - 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) {
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 1) fprintf(stderr, "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
|
|
|
|
2012-09-22 05:25:08 +00:00
|
|
|
old->extra_delta32 = new->extra_delta32 - old->extra_delta32;
|
|
|
|
|
old->extra_delta32 &= 0xFFFFFFFF;
|
|
|
|
|
|
|
|
|
|
old->extra_delta64 = new->extra_delta64 - old->extra_delta64;
|
|
|
|
|
|
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-09-22 05:25:08 +00:00
|
|
|
* Extra MSR is just a snapshot, simply copy latest w/o subtracting
|
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-09-22 03:45:46 +00:00
|
|
|
old->extra_msr32 = new->extra_msr32;
|
|
|
|
|
old->extra_msr64 = new->extra_msr64;
|
2013-02-10 22:19:24 +00:00
|
|
|
|
|
|
|
|
if (do_smi)
|
|
|
|
|
old->smi_count = new->smi_count - old->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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
/* 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 */
|
|
|
|
|
delta_thread(t, t2, c2); /* c2 is core delta */
|
|
|
|
|
|
|
|
|
|
/* calculate package delta only for 1st core in package */
|
|
|
|
|
if (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)
|
|
|
|
|
delta_package(p, p2);
|
|
|
|
|
|
2010-10-23 03:53:03 +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
|
|
|
void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
|
|
|
|
|
{
|
|
|
|
|
t->tsc = 0;
|
|
|
|
|
t->aperf = 0;
|
|
|
|
|
t->mperf = 0;
|
|
|
|
|
t->c1 = 0;
|
|
|
|
|
|
2013-02-10 22:19:24 +00:00
|
|
|
t->smi_count = 0;
|
2012-09-22 05:25:08 +00:00
|
|
|
t->extra_delta32 = 0;
|
|
|
|
|
t->extra_delta64 = 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;
|
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;
|
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;
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc3)
|
|
|
|
|
p->pc3 = 0;
|
|
|
|
|
if (do_pc6)
|
|
|
|
|
p->pc6 = 0;
|
|
|
|
|
if (do_pc7)
|
|
|
|
|
p->pc7 = 0;
|
2012-11-21 13:22:43 +00:00
|
|
|
p->pc8 = 0;
|
|
|
|
|
p->pc9 = 0;
|
|
|
|
|
p->pc10 = 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;
|
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
|
|
|
{
|
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
|
|
|
|
2012-09-22 05:25:08 +00:00
|
|
|
average.threads.extra_delta32 += t->extra_delta32;
|
|
|
|
|
average.threads.extra_delta64 += t->extra_delta64;
|
|
|
|
|
|
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;
|
|
|
|
|
|
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);
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
average.packages.pc2 += p->pc2;
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc3)
|
|
|
|
|
average.packages.pc3 += p->pc3;
|
|
|
|
|
if (do_pc6)
|
|
|
|
|
average.packages.pc6 += p->pc6;
|
|
|
|
|
if (do_pc7)
|
|
|
|
|
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
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
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;
|
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)
|
|
|
|
|
{
|
|
|
|
|
clear_counters(&average.threads, &average.cores, &average.packages);
|
|
|
|
|
|
|
|
|
|
for_all_cpus(sum_counters, t, c, p);
|
|
|
|
|
|
|
|
|
|
average.threads.tsc /= topo.num_cpus;
|
|
|
|
|
average.threads.aperf /= topo.num_cpus;
|
|
|
|
|
average.threads.mperf /= topo.num_cpus;
|
|
|
|
|
average.threads.c1 /= topo.num_cpus;
|
|
|
|
|
|
2012-09-22 05:25:08 +00:00
|
|
|
average.threads.extra_delta32 /= topo.num_cpus;
|
|
|
|
|
average.threads.extra_delta32 &= 0xFFFFFFFF;
|
|
|
|
|
|
|
|
|
|
average.threads.extra_delta64 /= 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
|
|
|
average.cores.c3 /= topo.num_cores;
|
|
|
|
|
average.cores.c6 /= topo.num_cores;
|
|
|
|
|
average.cores.c7 /= topo.num_cores;
|
|
|
|
|
|
|
|
|
|
average.packages.pc2 /= topo.num_packages;
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc3)
|
|
|
|
|
average.packages.pc3 /= topo.num_packages;
|
|
|
|
|
if (do_pc6)
|
|
|
|
|
average.packages.pc6 /= topo.num_packages;
|
|
|
|
|
if (do_pc7)
|
|
|
|
|
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;
|
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
|
|
|
|
|
|
|
|
|
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;
|
2012-03-30 01:44:40 +00:00
|
|
|
|
2012-11-09 03:38:05 +00:00
|
|
|
if (cpu_migrate(cpu)) {
|
|
|
|
|
fprintf(stderr, "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
|
|
|
|
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 */
|
|
|
|
|
|
|
|
|
|
if (has_aperf) {
|
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;
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-10 22:19:24 +00:00
|
|
|
if (do_smi) {
|
|
|
|
|
if (get_msr(cpu, MSR_SMI_COUNT, &msr))
|
|
|
|
|
return -5;
|
|
|
|
|
t->smi_count = msr & 0xFFFFFFFF;
|
|
|
|
|
}
|
2012-09-22 05:25:08 +00:00
|
|
|
if (extra_delta_offset32) {
|
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, extra_delta_offset32, &msr))
|
2012-09-22 05:25:08 +00:00
|
|
|
return -5;
|
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
|
|
|
t->extra_delta32 = msr & 0xFFFFFFFF;
|
2012-09-22 05:25:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (extra_delta_offset64)
|
|
|
|
|
if (get_msr(cpu, extra_delta_offset64, &t->extra_delta64))
|
2012-09-22 03:45:46 +00:00
|
|
|
return -5;
|
|
|
|
|
|
2012-09-22 05:25:08 +00:00
|
|
|
if (extra_msr_offset32) {
|
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, extra_msr_offset32, &msr))
|
2012-09-22 05:25:08 +00:00
|
|
|
return -5;
|
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
|
|
|
t->extra_msr32 = msr & 0xFFFFFFFF;
|
2012-09-22 05:25:08 +00:00
|
|
|
}
|
|
|
|
|
|
2012-09-22 03:45:46 +00:00
|
|
|
if (extra_msr_offset64)
|
|
|
|
|
if (get_msr(cpu, extra_msr_offset64, &t->extra_msr64))
|
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 -5;
|
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
if (use_c1_residency_msr) {
|
|
|
|
|
if (get_msr(cpu, MSR_CORE_C1_RES, &t->c1))
|
|
|
|
|
return -6;
|
|
|
|
|
}
|
|
|
|
|
|
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))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
if (do_nhm_cstates && !do_slm_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_C3_RESIDENCY, &c->c3))
|
|
|
|
|
return -6;
|
2013-11-09 05:30:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (do_nhm_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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (do_snb_cstates)
|
|
|
|
|
if (get_msr(cpu, MSR_CORE_C7_RESIDENCY, &c->c7))
|
|
|
|
|
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
|
|
|
if (do_dts) {
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
|
|
|
|
|
return -9;
|
|
|
|
|
c->core_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
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))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc3)
|
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;
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc6)
|
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_C6_RESIDENCY, &p->pc6))
|
|
|
|
|
return -10;
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc2)
|
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;
|
2015-02-10 04:39:45 +00:00
|
|
|
if (do_pc7)
|
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;
|
2012-11-21 13:22:43 +00:00
|
|
|
if (do_c8_c9_c10) {
|
|
|
|
|
if (get_msr(cpu, MSR_PKG_C8_RESIDENCY, &p->pc8))
|
|
|
|
|
return -13;
|
|
|
|
|
if (get_msr(cpu, MSR_PKG_C9_RESIDENCY, &p->pc9))
|
|
|
|
|
return -13;
|
|
|
|
|
if (get_msr(cpu, MSR_PKG_C10_RESIDENCY, &p->pc10))
|
|
|
|
|
return -13;
|
|
|
|
|
}
|
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;
|
|
|
|
|
}
|
|
|
|
|
if (do_rapl & RAPL_CORES) {
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
if (do_ptm) {
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
|
|
|
|
|
return -17;
|
|
|
|
|
p->pkg_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
|
|
|
|
|
}
|
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 */
|
|
|
|
|
#define PCLUNL 12 /* Unlimited */
|
|
|
|
|
|
|
|
|
|
int pkg_cstate_limit = PCLUKN;
|
|
|
|
|
char *pkg_cstate_limit_strings[] = { "reserved", "unknown", "pc0", "pc1", "pc2",
|
|
|
|
|
"pc3", "pc4", "pc6", "pc6n", "pc6r", "pc7", "pc7s", "unlimited"};
|
|
|
|
|
|
|
|
|
|
int nhm_pkg_cstate_limits[8] = {PCL__0, PCL__1, PCL__3, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLUNL};
|
|
|
|
|
int snb_pkg_cstate_limits[8] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCL__7, PCL_7S, PCLRSV, PCLUNL};
|
|
|
|
|
int hsw_pkg_cstate_limits[8] = {PCL__0, PCL__2, PCL__3, PCL__6, PCL__7, PCL_7S, PCLRSV, PCLUNL};
|
|
|
|
|
int slv_pkg_cstate_limits[8] = {PCL__0, PCL__1, PCLRSV, PCLRSV, PCL__4, PCLRSV, PCL__6, PCL__7};
|
|
|
|
|
int amt_pkg_cstate_limits[8] = {PCL__0, PCL__1, PCL__2, PCLRSV, PCLRSV, PCLRSV, PCL__6, PCL__7};
|
|
|
|
|
int phi_pkg_cstate_limits[8] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCLRSV, PCLRSV, PCLRSV, PCLUNL};
|
|
|
|
|
|
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 print_verbose_header(void)
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
|
|
|
|
unsigned long long msr;
|
|
|
|
|
unsigned int ratio;
|
|
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
if (!do_nhm_platform_info)
|
2010-10-23 03:53:03 +00:00
|
|
|
return;
|
|
|
|
|
|
2012-10-31 05:29:52 +00:00
|
|
|
get_msr(0, MSR_NHM_PLATFORM_INFO, &msr);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2013-01-31 20:22:15 +00:00
|
|
|
fprintf(stderr, "cpu0: MSR_NHM_PLATFORM_INFO: 0x%08llx\n", msr);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
ratio = (msr >> 40) & 0xFF;
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max efficiency\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0xFF;
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz TSC frequency\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
2013-01-31 20:22:15 +00:00
|
|
|
get_msr(0, MSR_IA32_POWER_CTL, &msr);
|
2013-11-09 05:30:16 +00:00
|
|
|
fprintf(stderr, "cpu0: MSR_IA32_POWER_CTL: 0x%08llx (C1E auto-promotion: %sabled)\n",
|
2013-01-31 20:22:15 +00:00
|
|
|
msr, msr & 0x2 ? "EN" : "DIS");
|
|
|
|
|
|
2012-09-21 04:01:31 +00:00
|
|
|
if (!do_ivt_turbo_ratio_limit)
|
|
|
|
|
goto print_nhm_turbo_ratio_limits;
|
|
|
|
|
|
|
|
|
|
get_msr(0, MSR_IVT_TURBO_RATIO_LIMIT, &msr);
|
|
|
|
|
|
2013-01-31 20:22:15 +00:00
|
|
|
fprintf(stderr, "cpu0: MSR_IVT_TURBO_RATIO_LIMIT: 0x%08llx\n", msr);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
|
|
|
|
ratio = (msr >> 56) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 16 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 48) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 15 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 40) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 14 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 32) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 13 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 24) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 12 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 16) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 11 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 10 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 0) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 9 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
print_nhm_turbo_ratio_limits:
|
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
|
|
|
get_msr(0, MSR_NHM_SNB_PKG_CST_CFG_CTL, &msr);
|
|
|
|
|
|
|
|
|
|
#define SNB_C1_AUTO_UNDEMOTE (1UL << 27)
|
|
|
|
|
#define SNB_C3_AUTO_UNDEMOTE (1UL << 28)
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "cpu0: MSR_NHM_SNB_PKG_CST_CFG_CTL: 0x%08llx", msr);
|
|
|
|
|
|
2015-02-10 04:39:45 +00:00
|
|
|
fprintf(stderr, " (%s%s%s%s%slocked: pkg-cstate-limit=%d: %s)\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
|
|
|
(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",
|
2015-02-10 04:39:45 +00:00
|
|
|
(unsigned int)msr & 7,
|
|
|
|
|
pkg_cstate_limit_strings[pkg_cstate_limit]);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
if (!do_nhm_turbo_ratio_limit)
|
2010-10-23 03:53:03 +00:00
|
|
|
return;
|
|
|
|
|
|
2012-10-31 05:29:52 +00:00
|
|
|
get_msr(0, MSR_NHM_TURBO_RATIO_LIMIT, &msr);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2013-01-31 20:22:15 +00:00
|
|
|
fprintf(stderr, "cpu0: MSR_NHM_TURBO_RATIO_LIMIT: 0x%08llx\n", msr);
|
2012-09-21 04:01:31 +00:00
|
|
|
|
|
|
|
|
ratio = (msr >> 56) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 8 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 48) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 7 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 40) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 6 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 32) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 5 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
ratio = (msr >> 24) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 4 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 16) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 3 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 8) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 2 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
|
|
|
|
|
|
|
|
|
ratio = (msr >> 0) & 0xFF;
|
|
|
|
|
if (ratio)
|
|
|
|
|
fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 1 active cores\n",
|
|
|
|
|
ratio, bclk, ratio * bclk);
|
2014-08-15 06:39:52 +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 free_all_buffers(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
|
|
|
CPU_FREE(cpu_present_set);
|
|
|
|
|
cpu_present_set = NULL;
|
|
|
|
|
cpu_present_set = 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;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
2013-08-21 00:20:17 +00:00
|
|
|
/*
|
|
|
|
|
* Open a file, and exit on failure
|
|
|
|
|
*/
|
|
|
|
|
FILE *fopen_or_die(const char *path, const char *mode)
|
|
|
|
|
{
|
|
|
|
|
FILE *filep = fopen(path, "r");
|
2013-08-21 00:20:18 +00:00
|
|
|
if (!filep)
|
|
|
|
|
err(1, "%s: open failed", path);
|
2013-08-21 00:20:17 +00:00
|
|
|
return 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
|
|
|
/*
|
2013-08-21 00:20:16 +00:00
|
|
|
* Parse a file containing a single 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
|
|
|
*/
|
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);
|
2013-08-21 00:20:17 +00:00
|
|
|
filep = fopen_or_die(path, "r");
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* cpu_is_first_sibling_in_core(cpu)
|
|
|
|
|
* return 1 if given CPU is 1st HT sibling in the core
|
|
|
|
|
*/
|
|
|
|
|
int cpu_is_first_sibling_in_core(int cpu)
|
|
|
|
|
{
|
|
|
|
|
return cpu == parse_int_file("/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
|
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_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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
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 get_num_ht_siblings(int cpu)
|
|
|
|
|
{
|
|
|
|
|
char path[80];
|
|
|
|
|
FILE *filep;
|
|
|
|
|
int sib1, sib2;
|
|
|
|
|
int matches;
|
|
|
|
|
char character;
|
|
|
|
|
|
|
|
|
|
sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
|
2013-08-21 00:20:17 +00:00
|
|
|
filep = fopen_or_die(path, "r");
|
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 format:
|
|
|
|
|
* if a pair of number with a character between: 2 siblings (eg. 1-2, or 1,4)
|
|
|
|
|
* otherwinse 1 sibling (self).
|
|
|
|
|
*/
|
|
|
|
|
matches = fscanf(filep, "%d%c%d\n", &sib1, &character, &sib2);
|
|
|
|
|
|
|
|
|
|
fclose(filep);
|
|
|
|
|
|
|
|
|
|
if (matches == 3)
|
|
|
|
|
return 2;
|
|
|
|
|
else
|
|
|
|
|
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
|
|
|
* 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)
|
|
|
|
|
{
|
|
|
|
|
int retval, pkg_no, core_no, thread_no;
|
|
|
|
|
|
|
|
|
|
for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
|
|
|
|
|
for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
|
|
|
|
|
for (thread_no = 0; thread_no <
|
|
|
|
|
topo.num_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, pkg_no);
|
|
|
|
|
|
|
|
|
|
if (cpu_is_not_present(t->cpu_id))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
t2 = GET_THREAD(thread_base2, thread_no, core_no, pkg_no);
|
|
|
|
|
|
|
|
|
|
c = GET_CORE(core_base, core_no, pkg_no);
|
|
|
|
|
c2 = GET_CORE(core_base2, core_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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
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
|
|
|
{
|
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 (topo.max_cpu_num < cpu)
|
|
|
|
|
topo.max_cpu_num = cpu;
|
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
|
|
|
topo.num_cpus += 1;
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
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
|
|
|
restart:
|
2012-11-09 03:38:05 +00:00
|
|
|
restarted++;
|
|
|
|
|
|
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) {
|
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;
|
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;
|
|
|
|
|
}
|
|
|
|
|
sleep(interval_sec);
|
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 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_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS);
|
|
|
|
|
compute_average(EVEN_COUNTERS);
|
|
|
|
|
format_all_counters(EVEN_COUNTERS);
|
|
|
|
|
flush_stdout();
|
2012-03-30 02:19:58 +00:00
|
|
|
sleep(interval_sec);
|
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 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_2(delta_cpu, EVEN_COUNTERS, ODD_COUNTERS);
|
|
|
|
|
compute_average(ODD_COUNTERS);
|
|
|
|
|
format_all_counters(ODD_COUNTERS);
|
|
|
|
|
flush_stdout();
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void check_dev_msr()
|
|
|
|
|
{
|
|
|
|
|
struct stat sb;
|
|
|
|
|
|
2013-08-21 00:20:18 +00:00
|
|
|
if (stat("/dev/cpu/0/msr", &sb))
|
2015-01-23 05:12:33 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
/* 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 */
|
|
|
|
|
if (euidaccess("/dev/cpu/0/msr", R_OK)) {
|
|
|
|
|
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
|
|
|
|
|
*
|
|
|
|
|
* MSR_NHM_PLATFORM_INFO 0x000000ce
|
|
|
|
|
* MSR_NHM_SNB_PKG_CST_CFG_CTL 0x000000e2
|
|
|
|
|
*
|
|
|
|
|
* 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:
|
|
|
|
|
* sets global pkg_cstate_limit to decode MSR_NHM_SNB_PKG_CST_CFG_CTL
|
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;
|
|
|
|
|
int *pkg_cstate_limits;
|
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
if (!genuine_intel)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
|
case 0x1A: /* Core i7, Xeon 5500 series - Bloomfield, Gainstown NHM-EP */
|
|
|
|
|
case 0x1E: /* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */
|
|
|
|
|
case 0x1F: /* Core i7 and i5 Processor - Nehalem */
|
|
|
|
|
case 0x25: /* Westmere Client - Clarkdale, Arrandale */
|
|
|
|
|
case 0x2C: /* Westmere EP - Gulftown */
|
2015-02-10 04:39:45 +00:00
|
|
|
case 0x2E: /* Nehalem-EX Xeon - Beckton */
|
|
|
|
|
case 0x2F: /* Westmere-EX Xeon - Eagleton */
|
|
|
|
|
pkg_cstate_limits = nhm_pkg_cstate_limits;
|
|
|
|
|
break;
|
2010-10-23 03:53:03 +00:00
|
|
|
case 0x2A: /* SNB */
|
|
|
|
|
case 0x2D: /* SNB Xeon */
|
2011-11-18 08:32:01 +00:00
|
|
|
case 0x3A: /* IVB */
|
2012-09-26 22:11:31 +00:00
|
|
|
case 0x3E: /* IVB Xeon */
|
2015-02-10 04:39:45 +00:00
|
|
|
pkg_cstate_limits = snb_pkg_cstate_limits;
|
|
|
|
|
break;
|
2013-01-08 06:26:07 +00:00
|
|
|
case 0x3C: /* HSW */
|
2013-12-03 07:19:19 +00:00
|
|
|
case 0x3F: /* HSX */
|
2013-01-08 06:26:07 +00:00
|
|
|
case 0x45: /* HSW */
|
2013-03-15 14:58:02 +00:00
|
|
|
case 0x46: /* HSW */
|
2014-02-28 04:28:53 +00:00
|
|
|
case 0x3D: /* BDW */
|
2015-02-10 20:38:04 +00:00
|
|
|
case 0x47: /* BDW */
|
2014-02-28 04:28:53 +00:00
|
|
|
case 0x4F: /* BDX */
|
|
|
|
|
case 0x56: /* BDX-DE */
|
2015-02-10 04:39:45 +00:00
|
|
|
pkg_cstate_limits = hsw_pkg_cstate_limits;
|
|
|
|
|
break;
|
|
|
|
|
case 0x37: /* BYT */
|
|
|
|
|
case 0x4D: /* AVN */
|
|
|
|
|
pkg_cstate_limits = slv_pkg_cstate_limits;
|
|
|
|
|
break;
|
|
|
|
|
case 0x4C: /* AMT */
|
|
|
|
|
pkg_cstate_limits = amt_pkg_cstate_limits;
|
|
|
|
|
break;
|
|
|
|
|
case 0x57: /* PHI */
|
|
|
|
|
pkg_cstate_limits = phi_pkg_cstate_limits;
|
|
|
|
|
break;
|
2010-10-23 03:53:03 +00:00
|
|
|
default:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2015-02-10 04:39:45 +00:00
|
|
|
get_msr(0, MSR_NHM_SNB_PKG_CST_CFG_CTL, &msr);
|
|
|
|
|
|
|
|
|
|
pkg_cstate_limit = pkg_cstate_limits[msr & 0x7];
|
|
|
|
|
|
|
|
|
|
return 1;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
2015-01-23 05:12:33 +00:00
|
|
|
int has_nhm_turbo_ratio_limit(unsigned int family, unsigned int model)
|
|
|
|
|
{
|
|
|
|
|
switch (model) {
|
|
|
|
|
/* Nehalem compatible, but do not include turbo-ratio limit support */
|
|
|
|
|
case 0x2E: /* Nehalem-EX Xeon - Beckton */
|
|
|
|
|
case 0x2F: /* Westmere-EX Xeon - Eagleton */
|
|
|
|
|
return 0;
|
|
|
|
|
default:
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
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) {
|
|
|
|
|
case 0x3E: /* IVB Xeon */
|
|
|
|
|
return 1;
|
|
|
|
|
default:
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
|
* 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)) {
|
|
|
|
|
fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_ENERGY_PERF_BIAS, &msr))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
switch (msr & 0x7) {
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_IA32_ENERGY_PERF_BIAS: 0x%08llx (%s)\n", cpu, msr, epb_string);
|
|
|
|
|
|
|
|
|
|
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)) {
|
|
|
|
|
fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (do_core_perf_limit_reasons) {
|
|
|
|
|
get_msr(cpu, MSR_CORE_PERF_LIMIT_REASONS, &msr);
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_CORE_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
|
|
|
|
|
fprintf(stderr, " (Active: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)",
|
|
|
|
|
(msr & 1 << 0) ? "PROCHOT, " : "",
|
|
|
|
|
(msr & 1 << 1) ? "ThermStatus, " : "",
|
|
|
|
|
(msr & 1 << 2) ? "bit2, " : "",
|
|
|
|
|
(msr & 1 << 4) ? "Graphics, " : "",
|
|
|
|
|
(msr & 1 << 5) ? "Auto-HWP, " : "",
|
|
|
|
|
(msr & 1 << 6) ? "VR-Therm, " : "",
|
|
|
|
|
(msr & 1 << 8) ? "Amps, " : "",
|
|
|
|
|
(msr & 1 << 9) ? "CorePwr, " : "",
|
|
|
|
|
(msr & 1 << 10) ? "PkgPwrL1, " : "",
|
|
|
|
|
(msr & 1 << 11) ? "PkgPwrL2, " : "",
|
|
|
|
|
(msr & 1 << 12) ? "MultiCoreTurbo, " : "",
|
|
|
|
|
(msr & 1 << 13) ? "Transitions, " : "",
|
|
|
|
|
(msr & 1 << 14) ? "bit14, " : "",
|
|
|
|
|
(msr & 1 << 15) ? "bit15, " : "");
|
|
|
|
|
fprintf(stderr, " (Logged: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
|
|
|
|
|
(msr & 1 << 16) ? "PROCHOT, " : "",
|
|
|
|
|
(msr & 1 << 17) ? "ThermStatus, " : "",
|
|
|
|
|
(msr & 1 << 18) ? "bit18, " : "",
|
|
|
|
|
(msr & 1 << 20) ? "Graphics, " : "",
|
|
|
|
|
(msr & 1 << 21) ? "Auto-HWP, " : "",
|
|
|
|
|
(msr & 1 << 22) ? "VR-Therm, " : "",
|
|
|
|
|
(msr & 1 << 24) ? "Amps, " : "",
|
|
|
|
|
(msr & 1 << 25) ? "CorePwr, " : "",
|
|
|
|
|
(msr & 1 << 26) ? "PkgPwrL1, " : "",
|
|
|
|
|
(msr & 1 << 27) ? "PkgPwrL2, " : "",
|
|
|
|
|
(msr & 1 << 28) ? "MultiCoreTurbo, " : "",
|
|
|
|
|
(msr & 1 << 29) ? "Transitions, " : "",
|
|
|
|
|
(msr & 1 << 30) ? "bit30, " : "",
|
|
|
|
|
(msr & 1 << 31) ? "bit31, " : "");
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
if (do_gfx_perf_limit_reasons) {
|
|
|
|
|
get_msr(cpu, MSR_GFX_PERF_LIMIT_REASONS, &msr);
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_GFX_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
|
|
|
|
|
fprintf(stderr, " (Active: %s%s%s%s%s%s%s%s)",
|
|
|
|
|
(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, " : "");
|
|
|
|
|
fprintf(stderr, " (Logged: %s%s%s%s%s%s%s%s)\n",
|
|
|
|
|
(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);
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_RING_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
|
|
|
|
|
fprintf(stderr, " (Active: %s%s%s%s%s%s)",
|
|
|
|
|
(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, " : "");
|
|
|
|
|
fprintf(stderr, " (Logged: %s%s%s%s%s%s)\n",
|
|
|
|
|
(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 */
|
|
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
double get_tdp(model)
|
|
|
|
|
{
|
|
|
|
|
unsigned long long msr;
|
|
|
|
|
|
|
|
|
|
if (do_rapl & RAPL_PKG_POWER_INFO)
|
|
|
|
|
if (!get_msr(0, MSR_PKG_POWER_INFO, &msr))
|
|
|
|
|
return ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
|
|
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
|
case 0x37:
|
|
|
|
|
case 0x4D:
|
|
|
|
|
return 30.0;
|
|
|
|
|
default:
|
|
|
|
|
return 135.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
|
|
|
/*
|
|
|
|
|
* rapl_probe()
|
|
|
|
|
*
|
2013-11-09 05:30:16 +00:00
|
|
|
* sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_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
|
|
|
*/
|
|
|
|
|
void rapl_probe(unsigned int family, unsigned int model)
|
|
|
|
|
{
|
|
|
|
|
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 (!genuine_intel)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
|
case 0x2A:
|
|
|
|
|
case 0x3A:
|
2013-01-08 06:26:07 +00:00
|
|
|
case 0x3C: /* HSW */
|
|
|
|
|
case 0x45: /* HSW */
|
2013-03-15 14:58:02 +00:00
|
|
|
case 0x46: /* HSW */
|
2014-02-28 04:28:53 +00:00
|
|
|
case 0x3D: /* BDW */
|
2015-02-10 20:38:04 +00:00
|
|
|
case 0x47: /* BDW */
|
2013-11-09 05:30:16 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_GFX | 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
|
|
|
break;
|
2013-12-03 07:19:19 +00:00
|
|
|
case 0x3F: /* HSX */
|
2014-02-28 04:28:53 +00:00
|
|
|
case 0x4F: /* BDX */
|
|
|
|
|
case 0x56: /* BDX-DE */
|
2013-12-03 07:19:19 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
|
|
|
|
|
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
|
|
|
case 0x2D:
|
|
|
|
|
case 0x3E:
|
2013-11-09 05:30:16 +00:00
|
|
|
do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_PKG_PERF_STATUS | RAPL_DRAM_PERF_STATUS | RAPL_PKG_POWER_INFO;
|
|
|
|
|
break;
|
|
|
|
|
case 0x37: /* BYT */
|
|
|
|
|
case 0x4D: /* AVN */
|
|
|
|
|
do_rapl = RAPL_PKG | RAPL_CORES ;
|
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;
|
|
|
|
|
default:
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* units on package 0, verify later other packages match */
|
|
|
|
|
if (get_msr(0, MSR_RAPL_POWER_UNIT, &msr))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
rapl_power_units = 1.0 / (1 << (msr & 0xF));
|
2013-11-09 05:30:16 +00:00
|
|
|
if (model == 0x37)
|
|
|
|
|
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
|
|
|
|
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
|
|
|
|
2013-11-09 05:30:16 +00:00
|
|
|
tdp = get_tdp(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;
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug)
|
2013-11-09 05:30:16 +00:00
|
|
|
fprintf(stderr, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-15 06:39:52 +00:00
|
|
|
void perf_limit_reasons_probe(family, model)
|
|
|
|
|
{
|
|
|
|
|
if (!genuine_intel)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (family != 6)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
switch (model) {
|
|
|
|
|
case 0x3C: /* HSW */
|
|
|
|
|
case 0x45: /* HSW */
|
|
|
|
|
case 0x46: /* HSW */
|
|
|
|
|
do_gfx_perf_limit_reasons = 1;
|
|
|
|
|
case 0x3F: /* HSX */
|
|
|
|
|
do_core_perf_limit_reasons = 1;
|
|
|
|
|
do_ring_perf_limit_reasons = 1;
|
|
|
|
|
default:
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
|
unsigned int dts;
|
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
|
|
if (!(do_dts || do_ptm))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
cpu = t->cpu_id;
|
|
|
|
|
|
|
|
|
|
/* DTS is per-core, no need to print for each thread */
|
|
|
|
|
if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (cpu_migrate(cpu)) {
|
|
|
|
|
fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
|
|
|
|
|
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;
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_IA32_PACKAGE_THERM_STATUS: 0x%08llx (%d C)\n",
|
|
|
|
|
cpu, msr, tcc_activation_temp - dts);
|
|
|
|
|
|
|
|
|
|
#ifdef THERM_DEBUG
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, &msr))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
dts = (msr >> 16) & 0x7F;
|
|
|
|
|
dts2 = (msr >> 8) & 0x7F;
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_IA32_PACKAGE_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
|
|
|
|
|
cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (do_dts) {
|
|
|
|
|
unsigned int resolution;
|
|
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
dts = (msr >> 16) & 0x7F;
|
|
|
|
|
resolution = (msr >> 27) & 0xF;
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_IA32_THERM_STATUS: 0x%08llx (%d C +/- %d)\n",
|
|
|
|
|
cpu, msr, tcc_activation_temp - dts, resolution);
|
|
|
|
|
|
|
|
|
|
#ifdef THERM_DEBUG
|
|
|
|
|
if (get_msr(cpu, MSR_IA32_THERM_INTERRUPT, &msr))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
dts = (msr >> 16) & 0x7F;
|
|
|
|
|
dts2 = (msr >> 8) & 0x7F;
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_IA32_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
|
|
|
|
|
cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void print_power_limit_msr(int cpu, unsigned long long msr, char *label)
|
|
|
|
|
{
|
|
|
|
|
fprintf(stderr, "cpu%d: %s: %sabled (%f Watts, %f sec, clamp %sabled)\n",
|
|
|
|
|
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;
|
|
|
|
|
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)) {
|
|
|
|
|
fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr))
|
|
|
|
|
return -1;
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
fprintf(stderr, "cpu%d: MSR_RAPL_POWER_UNIT: 0x%08llx "
|
|
|
|
|
"(%f Watts, %f Joules, %f sec.)\n", cpu, msr,
|
2013-11-09 05:30:16 +00:00
|
|
|
rapl_power_units, rapl_energy_units, rapl_time_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
|
|
|
}
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_PKG_POWER_INFO: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_PKG_POWER_LIMIT: 0x%08llx (%slocked)\n",
|
|
|
|
|
cpu, msr, (msr >> 63) & 1 ? "": "UN");
|
|
|
|
|
|
|
|
|
|
print_power_limit_msr(cpu, msr, "PKG Limit #1");
|
|
|
|
|
fprintf(stderr, "cpu%d: PKG Limit #2: %sabled (%f Watts, %f* sec, clamp %sabled)\n",
|
|
|
|
|
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");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (do_rapl & RAPL_DRAM) {
|
|
|
|
|
if (get_msr(cpu, MSR_DRAM_POWER_INFO, &msr))
|
|
|
|
|
return -6;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_DRAM_POWER_INFO,: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_DRAM_POWER_LIMIT, &msr))
|
|
|
|
|
return -9;
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_DRAM_POWER_LIMIT: 0x%08llx (%slocked)\n",
|
|
|
|
|
cpu, msr, (msr >> 31) & 1 ? "": "UN");
|
|
|
|
|
|
|
|
|
|
print_power_limit_msr(cpu, msr, "DRAM Limit");
|
|
|
|
|
}
|
2013-11-09 05:30:16 +00:00
|
|
|
if (do_rapl & RAPL_CORE_POLICY) {
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
if (get_msr(cpu, MSR_PP0_POLICY, &msr))
|
|
|
|
|
return -7;
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_PP0_POLICY: %lld\n", cpu, msr & 0xF);
|
2013-11-09 05:30:16 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (do_rapl & RAPL_CORES) {
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_PP0_POWER_LIMIT, &msr))
|
|
|
|
|
return -9;
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_PP0_POWER_LIMIT: 0x%08llx (%slocked)\n",
|
|
|
|
|
cpu, msr, (msr >> 31) & 1 ? "": "UN");
|
|
|
|
|
print_power_limit_msr(cpu, msr, "Cores Limit");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (do_rapl & RAPL_GFX) {
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
if (get_msr(cpu, MSR_PP1_POLICY, &msr))
|
|
|
|
|
return -8;
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_PP1_POLICY: %lld\n", cpu, msr & 0xF);
|
|
|
|
|
|
|
|
|
|
if (get_msr(cpu, MSR_PP1_POWER_LIMIT, &msr))
|
|
|
|
|
return -9;
|
|
|
|
|
fprintf(stderr, "cpu%d: MSR_PP1_POWER_LIMIT: 0x%08llx (%slocked)\n",
|
|
|
|
|
cpu, msr, (msr >> 31) & 1 ? "": "UN");
|
|
|
|
|
print_power_limit_msr(cpu, msr, "GFX Limit");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
|
case 0x2A:
|
|
|
|
|
case 0x2D:
|
2012-06-04 03:34:44 +00:00
|
|
|
case 0x3A: /* IVB */
|
2012-09-26 22:11:31 +00:00
|
|
|
case 0x3E: /* IVB Xeon */
|
2013-01-08 06:26:07 +00:00
|
|
|
case 0x3C: /* HSW */
|
|
|
|
|
case 0x3F: /* HSW */
|
|
|
|
|
case 0x45: /* HSW */
|
2013-03-15 14:58:02 +00:00
|
|
|
case 0x46: /* HSW */
|
2014-02-28 04:28:53 +00:00
|
|
|
case 0x3D: /* BDW */
|
2015-02-10 20:38:04 +00:00
|
|
|
case 0x47: /* BDW */
|
2014-02-28 04:28:53 +00:00
|
|
|
case 0x4F: /* BDX */
|
|
|
|
|
case 0x56: /* BDX-DE */
|
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:
|
|
|
|
|
*
|
|
|
|
|
* MSR_PKG_C8_RESIDENCY 0x00000630
|
|
|
|
|
* MSR_PKG_C9_RESIDENCY 0x00000631
|
|
|
|
|
* MSR_PKG_C10_RESIDENCY 0x00000632
|
|
|
|
|
*/
|
|
|
|
|
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) {
|
2014-02-28 04:28:53 +00:00
|
|
|
case 0x45: /* HSW */
|
|
|
|
|
case 0x3D: /* BDW */
|
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) {
|
|
|
|
|
case 0x37: /* BYT */
|
|
|
|
|
case 0x4D: /* AVN */
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#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;
|
|
|
|
|
|
|
|
|
|
if (get_msr(0, MSR_FSB_FREQ, &msr))
|
|
|
|
|
fprintf(stderr, "SLM BCLK: unknown\n");
|
|
|
|
|
|
|
|
|
|
i = msr & 0xf;
|
|
|
|
|
if (i >= SLM_BCLK_FREQS) {
|
|
|
|
|
fprintf(stderr, "SLM BCLK[%d] invalid\n", i);
|
|
|
|
|
msr = 3;
|
|
|
|
|
}
|
|
|
|
|
freq = slm_freq_table[i];
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "SLM BCLK: %.1f Mhz\n", freq);
|
|
|
|
|
|
|
|
|
|
return freq;
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
double discover_bclk(unsigned int family, unsigned int model)
|
|
|
|
|
{
|
2015-01-23 05:12:33 +00:00
|
|
|
if (has_snb_msrs(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)) {
|
|
|
|
|
fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (tcc_activation_temp_override != 0) {
|
|
|
|
|
tcc_activation_temp = tcc_activation_temp_override;
|
|
|
|
|
fprintf(stderr, "cpu%d: Using cmdline TCC Target (%d C)\n",
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
if (get_msr(0, MSR_IA32_TEMPERATURE_TARGET, &msr))
|
|
|
|
|
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
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
fprintf(stderr, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C)\n",
|
|
|
|
|
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;
|
|
|
|
|
fprintf(stderr, "cpu%d: Guessing tjMax %d C, Please use -T to specify\n",
|
|
|
|
|
cpu, tcc_activation_temp);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2010-10-23 03:53:03 +00:00
|
|
|
void check_cpuid()
|
|
|
|
|
{
|
|
|
|
|
unsigned int eax, ebx, ecx, edx, max_level;
|
|
|
|
|
unsigned int fms, family, model, stepping;
|
|
|
|
|
|
|
|
|
|
eax = ebx = ecx = edx = 0;
|
|
|
|
|
|
2013-08-21 00:20:14 +00:00
|
|
|
__get_cpuid(0, &max_level, &ebx, &ecx, &edx);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
|
|
|
|
if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e)
|
|
|
|
|
genuine_intel = 1;
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
fprintf(stderr, "CPUID(0): %.4s%.4s%.4s ",
|
2010-10-23 03:53:03 +00:00
|
|
|
(char *)&ebx, (char *)&edx, (char *)&ecx);
|
|
|
|
|
|
2013-08-21 00:20:14 +00:00
|
|
|
__get_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;
|
|
|
|
|
if (family == 6 || family == 0xf)
|
|
|
|
|
model += ((fms >> 16) & 0xf) << 4;
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug)
|
2010-10-23 03:53:03 +00:00
|
|
|
fprintf(stderr, "%d CPUID levels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n",
|
|
|
|
|
max_level, family, model, stepping, family, model, stepping);
|
|
|
|
|
|
2013-08-21 00:20:18 +00:00
|
|
|
if (!(edx & (1 << 5)))
|
|
|
|
|
errx(1, "CPUID: no MSR");
|
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;
|
2013-08-21 00:20:14 +00:00
|
|
|
__get_cpuid(0x80000000, &max_level, &ebx, &ecx, &edx);
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-01-23 05:12:33 +00:00
|
|
|
if (max_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
|
|
|
|
|
*/
|
|
|
|
|
__get_cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
|
|
|
|
|
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
|
|
|
|
|
*/
|
|
|
|
|
|
2013-08-21 00:20:14 +00:00
|
|
|
__get_cpuid(0x6, &eax, &ebx, &ecx, &edx);
|
2011-01-21 14:11:19 +00:00
|
|
|
has_aperf = ecx & (1 << 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
|
|
|
do_dts = eax & (1 << 0);
|
|
|
|
|
do_ptm = eax & (1 << 6);
|
|
|
|
|
has_epb = ecx & (1 << 3);
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug)
|
2015-01-23 06:33:58 +00:00
|
|
|
fprintf(stderr, "CPUID(6): %sAPERF, %sDTS, %sPTM, %sEPB\n",
|
|
|
|
|
has_aperf ? "" : "No ",
|
|
|
|
|
do_dts ? "" : "No ",
|
|
|
|
|
do_ptm ? "" : "No ",
|
|
|
|
|
has_epb ? "" : "No ");
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-02-10 04:39:45 +00:00
|
|
|
do_nhm_platform_info = do_nhm_cstates = do_smi = probe_nhm_msrs(family, model);
|
2015-01-23 05:12:33 +00:00
|
|
|
do_snb_cstates = has_snb_msrs(family, model);
|
2015-02-10 04:39:45 +00:00
|
|
|
do_pc2 = do_snb_cstates && (pkg_cstate_limit >= PCL__2);
|
|
|
|
|
do_pc3 = (pkg_cstate_limit >= PCL__3);
|
|
|
|
|
do_pc6 = (pkg_cstate_limit >= PCL__6);
|
|
|
|
|
do_pc7 = do_snb_cstates && (pkg_cstate_limit >= PCL__7);
|
2015-01-23 05:12:33 +00:00
|
|
|
do_c8_c9_c10 = has_hsw_msrs(family, model);
|
2013-11-09 05:30:16 +00:00
|
|
|
do_slm_cstates = is_slm(family, model);
|
2010-10-23 03:53:03 +00:00
|
|
|
bclk = discover_bclk(family, model);
|
|
|
|
|
|
2015-02-10 04:39:45 +00:00
|
|
|
do_nhm_turbo_ratio_limit = do_nhm_platform_info && has_nhm_turbo_ratio_limit(family, model);
|
2012-09-21 04:01:31 +00:00
|
|
|
do_ivt_turbo_ratio_limit = has_ivt_turbo_ratio_limit(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
|
|
|
rapl_probe(family, model);
|
2014-08-15 06:39:52 +00:00
|
|
|
perf_limit_reasons_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
|
|
|
|
|
|
|
|
return;
|
2010-10-23 03:53:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
void help()
|
2010-10-23 03:53:03 +00:00
|
|
|
{
|
2015-02-10 06:56:38 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
|
"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"
|
|
|
|
|
"--debug run in \"debug\" mode\n"
|
|
|
|
|
"--interval sec Override default 5-second measurement interval\n"
|
|
|
|
|
"--help print this help message\n"
|
|
|
|
|
"--counter msr print 32-bit counter at address \"msr\"\n"
|
|
|
|
|
"--Counter msr print 64-bit Counter at address \"msr\"\n"
|
|
|
|
|
"--msr msr print 32-bit value at address \"msr\"\n"
|
|
|
|
|
"--MSR msr print 64-bit Value at address \"msr\"\n"
|
|
|
|
|
"--version print version information\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"For more help, run \"man turbostat\"\n");
|
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;
|
|
|
|
|
int max_siblings = 0;
|
|
|
|
|
struct cpu_topology {
|
|
|
|
|
int core_id;
|
|
|
|
|
int physical_package_id;
|
|
|
|
|
} *cpus;
|
|
|
|
|
|
|
|
|
|
/* Initialize num_cpus, max_cpu_num */
|
|
|
|
|
topo.num_cpus = 0;
|
|
|
|
|
topo.max_cpu_num = 0;
|
|
|
|
|
for_all_proc_cpus(count_cpus);
|
|
|
|
|
if (!summary_only && topo.num_cpus > 1)
|
|
|
|
|
show_cpu = 1;
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 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
|
|
|
fprintf(stderr, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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)
|
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
|
|
|
fprintf(stderr, "cpu%d NOT PRESENT\n", i);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
cpus[i].core_id = get_core_id(i);
|
|
|
|
|
if (cpus[i].core_id > max_core_id)
|
|
|
|
|
max_core_id = cpus[i].core_id;
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
siblings = get_num_ht_siblings(i);
|
|
|
|
|
if (siblings > max_siblings)
|
|
|
|
|
max_siblings = siblings;
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 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
|
|
|
fprintf(stderr, "cpu %d pkg %d core %d\n",
|
|
|
|
|
i, cpus[i].physical_package_id, cpus[i].core_id);
|
|
|
|
|
}
|
|
|
|
|
topo.num_cores_per_pkg = max_core_id + 1;
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 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
|
|
|
fprintf(stderr, "max_core_id %d, sizing for %d cores per package\n",
|
|
|
|
|
max_core_id, topo.num_cores_per_pkg);
|
|
|
|
|
if (!summary_only && topo.num_cores_per_pkg > 1)
|
|
|
|
|
show_core = 1;
|
|
|
|
|
|
|
|
|
|
topo.num_packages = max_package_id + 1;
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 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
|
|
|
fprintf(stderr, "max_package_id %d, sizing for %d packages\n",
|
|
|
|
|
max_package_id, topo.num_packages);
|
|
|
|
|
if (!summary_only && topo.num_packages > 1)
|
|
|
|
|
show_pkg = 1;
|
|
|
|
|
|
|
|
|
|
topo.num_threads_per_core = max_siblings;
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug > 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
|
|
|
fprintf(stderr, "max_siblings %d\n", max_siblings);
|
|
|
|
|
|
|
|
|
|
free(cpus);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
allocate_counters(struct thread_data **t, struct core_data **c, struct pkg_data **p)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
*t = calloc(topo.num_threads_per_core * topo.num_cores_per_pkg *
|
|
|
|
|
topo.num_packages, sizeof(struct thread_data));
|
|
|
|
|
if (*t == NULL)
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < topo.num_threads_per_core *
|
|
|
|
|
topo.num_cores_per_pkg * topo.num_packages; i++)
|
|
|
|
|
(*t)[i].cpu_id = -1;
|
|
|
|
|
|
|
|
|
|
*c = calloc(topo.num_cores_per_pkg * topo.num_packages,
|
|
|
|
|
sizeof(struct core_data));
|
|
|
|
|
if (*c == NULL)
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < topo.num_cores_per_pkg * topo.num_packages; i++)
|
|
|
|
|
(*c)[i].core_id = -1;
|
|
|
|
|
|
|
|
|
|
*p = calloc(topo.num_packages, sizeof(struct pkg_data));
|
|
|
|
|
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 cpu_id, core_num, pkg_num
|
|
|
|
|
* set FIRST_THREAD_IN_CORE and FIRST_CORE_IN_PACKAGE
|
|
|
|
|
*
|
|
|
|
|
* increment topo.num_cores when 1st core in pkg seen
|
|
|
|
|
*/
|
|
|
|
|
void init_counter(struct thread_data *thread_base, struct core_data *core_base,
|
|
|
|
|
struct pkg_data *pkg_base, int thread_num, int core_num,
|
|
|
|
|
int pkg_num, int cpu_id)
|
|
|
|
|
{
|
|
|
|
|
struct thread_data *t;
|
|
|
|
|
struct core_data *c;
|
|
|
|
|
struct pkg_data *p;
|
|
|
|
|
|
|
|
|
|
t = GET_THREAD(thread_base, thread_num, core_num, pkg_num);
|
|
|
|
|
c = GET_CORE(core_base, core_num, pkg_num);
|
|
|
|
|
p = GET_PKG(pkg_base, pkg_num);
|
|
|
|
|
|
|
|
|
|
t->cpu_id = cpu_id;
|
|
|
|
|
if (thread_num == 0) {
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
c->core_id = core_num;
|
|
|
|
|
p->package_id = pkg_num;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int initialize_counters(int cpu_id)
|
|
|
|
|
{
|
|
|
|
|
int my_thread_id, my_core_id, my_package_id;
|
|
|
|
|
|
|
|
|
|
my_package_id = get_physical_package_id(cpu_id);
|
|
|
|
|
my_core_id = get_core_id(cpu_id);
|
|
|
|
|
|
|
|
|
|
if (cpu_is_first_sibling_in_core(cpu_id)) {
|
|
|
|
|
my_thread_id = 0;
|
|
|
|
|
topo.num_cores++;
|
|
|
|
|
} else {
|
|
|
|
|
my_thread_id = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
init_counter(EVEN_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
|
|
|
|
|
init_counter(ODD_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void setup_all_buffers(void)
|
|
|
|
|
{
|
|
|
|
|
topology_probe();
|
|
|
|
|
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
|
|
|
|
2010-10-23 03:53:03 +00:00
|
|
|
void turbostat_init()
|
|
|
|
|
{
|
|
|
|
|
check_dev_msr();
|
2014-08-15 04:36:50 +00:00
|
|
|
check_permissions();
|
|
|
|
|
check_cpuid();
|
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
|
|
|
setup_all_buffers();
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug)
|
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_verbose_header();
|
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
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
for_all_cpus(print_epb, ODD_COUNTERS);
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug)
|
2014-08-15 06:39:52 +00:00
|
|
|
for_all_cpus(print_perf_limit, ODD_COUNTERS);
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
for_all_cpus(print_rapl, ODD_COUNTERS);
|
|
|
|
|
|
|
|
|
|
for_all_cpus(set_temperature_target, ODD_COUNTERS);
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (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
|
|
|
for_all_cpus(print_thermal, ODD_COUNTERS);
|
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
|
|
|
|
2012-11-01 04:08:19 +00:00
|
|
|
status = for_all_cpus(get_counters, EVEN_COUNTERS);
|
|
|
|
|
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);
|
|
|
|
|
} 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");
|
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
|
|
|
|
|
*/
|
|
|
|
|
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 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_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS);
|
|
|
|
|
compute_average(EVEN_COUNTERS);
|
|
|
|
|
format_all_counters(EVEN_COUNTERS);
|
|
|
|
|
flush_stderr();
|
2010-10-23 03:53:03 +00:00
|
|
|
|
2011-04-09 02:49:08 +00:00
|
|
|
fprintf(stderr, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);
|
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;
|
|
|
|
|
|
|
|
|
|
status = for_all_cpus(get_counters, ODD_COUNTERS);
|
|
|
|
|
if (status)
|
|
|
|
|
return status;
|
|
|
|
|
|
|
|
|
|
status = for_all_cpus(dump_counters, ODD_COUNTERS);
|
|
|
|
|
if (status)
|
|
|
|
|
return status;
|
|
|
|
|
|
|
|
|
|
flush_stdout();
|
|
|
|
|
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
void print_version() {
|
2015-02-10 20:38:04 +00:00
|
|
|
fprintf(stderr, "turbostat version 4.1 10-Feb, 2015"
|
2015-02-10 06:56:38 +00:00
|
|
|
" - Len Brown <lenb@kernel.org>\n");
|
|
|
|
|
}
|
|
|
|
|
|
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[] = {
|
|
|
|
|
{"Counter", required_argument, 0, 'C'},
|
|
|
|
|
{"counter", required_argument, 0, 'c'},
|
|
|
|
|
{"Dump", no_argument, 0, 'D'},
|
|
|
|
|
{"debug", no_argument, 0, 'd'},
|
|
|
|
|
{"interval", required_argument, 0, 'i'},
|
|
|
|
|
{"help", no_argument, 0, 'h'},
|
|
|
|
|
{"Joules", no_argument, 0, 'J'},
|
|
|
|
|
{"MSR", required_argument, 0, 'M'},
|
|
|
|
|
{"msr", required_argument, 0, 'm'},
|
|
|
|
|
{"Package", no_argument, 0, 'p'},
|
|
|
|
|
{"processor", no_argument, 0, 'p'},
|
|
|
|
|
{"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];
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
while ((opt = getopt_long_only(argc, argv, "C:c:Ddhi:JM:m:PpST:v",
|
|
|
|
|
long_options, &option_index)) != -1) {
|
2010-10-23 03:53:03 +00:00
|
|
|
switch (opt) {
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'C':
|
|
|
|
|
sscanf(optarg, "%x", &extra_delta_offset64);
|
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
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'c':
|
|
|
|
|
sscanf(optarg, "%x", &extra_delta_offset32);
|
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
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'D':
|
2014-01-23 15:13:15 +00:00
|
|
|
dump_only++;
|
|
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'd':
|
|
|
|
|
debug++;
|
2010-10-23 03:53:03 +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':
|
|
|
|
|
interval_sec = atoi(optarg);
|
|
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'J':
|
|
|
|
|
rapl_joules++;
|
2012-09-22 05:25:08 +00:00
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'M':
|
|
|
|
|
sscanf(optarg, "%x", &extra_msr_offset64);
|
2012-09-22 05:25:08 +00:00
|
|
|
break;
|
2012-09-22 03:45:46 +00:00
|
|
|
case 'm':
|
|
|
|
|
sscanf(optarg, "%x", &extra_msr_offset32);
|
|
|
|
|
break;
|
2015-02-10 06:56:38 +00:00
|
|
|
case 'P':
|
|
|
|
|
show_pkg_only++;
|
|
|
|
|
break;
|
|
|
|
|
case 'p':
|
|
|
|
|
show_core_only++;
|
2010-10-23 03:53:03 +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)
|
|
|
|
|
{
|
|
|
|
|
cmdline(argc, argv);
|
|
|
|
|
|
2015-02-10 06:56:38 +00:00
|
|
|
if (debug)
|
|
|
|
|
print_version();
|
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();
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
