This is the commit 0f7e6dd0ab7b1b02ef7e55749d6a34d6801c3973 from Linaro's PowerTOP repository. Author: John Mathew <johnx.mathew(a)intel.com&gt; Intel hyperthreaded cores does not exactly behave like if it was 2 real cores. - Actual HW cstate is roughly minimal cstate of the 2 threads. As most of the resources are shared, HW resources are only really powered down when both threads are idle. - Interrupts always wakes up the 2 threads. i.e. terminate the 2 mwait. So in case of an hyperthreaded core a wakeup event is affecting power only when both the threads are asleep. A wakeup event that occurs when one of the thread is active should not be considered as a wakeup event. In case of hyperthreaded cores the thread ids that execute on the same core will be reported in the sys/devices/system/cpu/cpu%i/topology/thread_siblings_list. A table is initially created with this thread sibling information corresponding to a cpu. When powertop gets a power_end event on a thread the thread_sibling table is looked up to identify the siblings of the cpu and each sibling is checked it has a wakeup pending. If any one sibling does not have a wakeup event pending the power end event is ignored. --- src/cpu/cpu.cpp | 28 ++++++++++++++++++++++++++++ src/cpu/cpu.h | 7 +++++++ src/process/do_process.cpp | 24 ++++++++++++++++++++++++ 3 files changed, 59 insertions(+), 0 deletions(-) diff --git a/src/cpu/cpu.cpp b/src/cpu/cpu.cpp index 941bcff..ab7e724 100644 --- a/src/cpu/cpu.cpp +++ b/src/cpu/cpu.cpp @@ -28,6 +28,7 @@ #include <string.h> #include <stdlib.h> #include <ncurses.h> +#include <sstream> #include "cpu.h" #include "cpudevice.h" @@ -38,12 +39,15 @@ #include "../display.h" #include "../report.h" +using namespace std; + static class abstract_cpu system_level; vector<class abstract_cpu *> all_cpus; static class perf_bundle * perf_events; +vector<struct thread_sibling_info *> thread_sibling_table; class perf_power_bundle: public perf_bundle @@ -163,6 +167,7 @@ static void handle_one_cpu(unsigned int number, char *vendor, int family, int mo unsigned int package_number = 0; unsigned int core_number = 0; class abstract_cpu *package, *core, *cpu; + vector<unsigned int> thread_siblings; sprintf(filename, "/sys/devices/system/cpu/cpu%i/topology/core_id", number); file.open(filename, ios::in); @@ -180,6 +185,29 @@ static void handle_one_cpu(unsigned int number, char *vendor, int family, int mo file.close(); } + sprintf(filename, + "/sys/devices/system/cpu/cpu%i/topology/thread_siblings_list", + number); + file.open(filename, ios::in); + if (file) { + string line; + getline(file,line); + istringstream linestream(line); + string item; + struct thread_sibling_info *info; + + while (getline(linestream, item, '-')) + thread_siblings.push_back(atoi(item.c_str())); + + if (thread_siblings.size() > 1) { + info = new struct thread_sibling_info; + info->cpunum = number; + info->thread_siblings = thread_siblings; + thread_sibling_table.push_back(info); + } + + file.close(); + } if (system_level.children.size() <= package_number) system_level.children.resize(package_number + 1, NULL); diff --git a/src/cpu/cpu.h b/src/cpu/cpu.h index b48ada9..54da093 100644 --- a/src/cpu/cpu.h +++ b/src/cpu/cpu.h @@ -39,6 +39,13 @@ class abstract_cpu; #define LEVEL_C0 -1 #define LEVEL_HEADER -2 +struct thread_sibling_info { + unsigned int cpunum; + vector<unsigned int> thread_siblings; +}; + +extern vector<struct thread_sibling_info *> thread_sibling_table; + #define PSTATE 1 #define CSTATE 2 diff --git a/src/process/do_process.cpp b/src/process/do_process.cpp index 731fe3e..60bc790 100644 --- a/src/process/do_process.cpp +++ b/src/process/do_process.cpp @@ -44,6 +44,7 @@ #include "../parameters/parameters.h" #include "../display.h" #include "../measurement/measurement.h" +#include "../cpu/cpu.h" static class perf_bundle * perf_events; @@ -147,6 +148,27 @@ static void change_blame(unsigned int cpu, class power_consumer *consumer, int l cpu_level[cpu] = level; } +static bool sibling_wakeup_pending(unsigned int cpu) +{ + unsigned int i, j; + struct thread_sibling_info *info; + bool wakeup_pending = true; + + for (i = 0; i < thread_sibling_table.size(); i++) { + info = thread_sibling_table[i]; + if (cpu != info->cpunum) + continue; + + for (j = 0; j < info->thread_siblings.size(); j++) + if (!get_wakeup_pending(info->thread_siblings[j])) { + wakeup_pending = false; + break; + } + } + + return wakeup_pending; +} + static void consume_blame(unsigned int cpu) { if (!get_wakeup_pending(cpu)) @@ -157,6 +179,8 @@ static void consume_blame(unsigned int cpu) return; if (!cpu_blame[cpu]) return; + if (!sibling_wakeup_pending(cpu)) + return; cpu_blame[cpu]->wake_ups++; cpu_blame[cpu] = NULL; -- 1.7.5.4