Get CPU microarchs for x86 hybrid cores

Author: rocallahan

src/CPUs.cc

@@ -4,10 +4,6 @@
 
 #include <sched.h>
 
-#include <fstream>
-#include <filesystem>
-#include <sstream>
-
 #include "log.h"
 
 using namespace std;
@@ -51,64 +47,6 @@ void CPUs::restore_initial_affinity(pid_t tid) const {
   }
 }
 
-static vector<CPUs::Group> get_cpu_arch_groups_from_sysfs() {
-  vector<CPUs::Group> result;
-  filesystem::path dir_path = "/sys/devices";
-  if (!filesystem::is_directory(dir_path)) {
-    return result;
-  }
-  for (const auto& entry : filesystem::directory_iterator(dir_path)) {
-    if (entry.path().filename().string().find("cpu_") != 0) {
-      continue;
-    }
-    ifstream file(entry.path() / "cpus");
-    if (!file.good()) {
-      LOG(warn) << "File " << entry.path().string() << "/cpus not found";
-      continue;
-    }
-    ostringstream sstr;
-    sstr << file.rdbuf();
-    string s = sstr.str();
-    size_t dash = s.find('-');
-    if (dash == string::npos) {
-      size_t end;
-      int cpu_index = stoi(s, &end);
-      if (end != s.size()) {
-        LOG(warn) << "Bad CPU index";
-        continue;
-      }
-      result.push_back(CPUs::Group{cpu_index, cpu_index + 1});
-    } else {
-      size_t end;
-      int cpu_index = stoi(s.substr(0, dash), &end);
-      if (end != dash) {
-        LOG(warn) << "Bad CPU index";
-        continue;
-      }
-      int cpu_index_end = stoi(s.substr(dash + 1), &end);
-      if (end != dash) {
-        LOG(warn) << "Bad end CPU index";
-        continue;
-      }
-      result.push_back(CPUs::Group{cpu_index, cpu_index_end + 1});
-    }
-  }
-  return result;
-}
-
-std::vector<CPUs::Group> CPUs::cpu_arch_groups() const {
-  std::vector<CPUs::Group> result = get_cpu_arch_groups_from_sysfs();
-  if (result.empty()) {
-    // Assume they're all the same arch.
-    int configured = sysconf(_SC_NPROCESSORS_CONF);
-    if (configured < 1) {
-      FATAL() << "sysconf failed";
-    }
-    result.push_back(Group{0, configured});
-  }
-  return result;
-}
-
 CPUs::CPUs() {
   // sched_getaffinity intersects the task's `cpu_mask`
   // (/proc/.../status Cpus_allowed_list) with `cpu_active_mask`

src/CPUs.h

@@ -13,20 +13,13 @@ class CPUs {
 public:
   static const CPUs& get();
 
+  // Returns the CPU indices in the initial affinity mask, in increasing order.
   std::vector<int> initial_affinity() const;
   static bool set_affinity_to_cpu(int cpu);
   // Restore the initial affinity mask to the given tid.
   // If unspecified, defaults to this thread.
   void restore_initial_affinity(pid_t tid = 0) const;
 
-  struct Group {
-    int start_cpu;
-    int end_cpu;
-  };
-  // Returns a list of CPU groups that all have the same microarchitecture.
-  // This list covers all available CPUs.
-  std::vector<Group> cpu_arch_groups() const;
-
 private:
   CPUs();
 

src/PerfCounters.cc

@@ -23,12 +23,15 @@
 #endif
 
 #include <algorithm>
+#include <filesystem>
 #include <fstream>
+#include <sstream>
 #include <limits>
 #include <regex>
 #include <string>
 #include <unordered_set>
 
+#include "CPUs.h"
 #include "Flags.h"
 #include "Session.h"
 #include "Task.h"
@@ -119,7 +122,10 @@ enum CpuMicroarch {
   IntelSilvermont,
   IntelGoldmont,
   IntelTremont,
-  LastIntel = IntelTremont,
+  IntelGracemont,
+  IntelCrestmont,
+  IntelSkymont,
+  LastIntel = IntelSkymont,
   FirstAMD,
   AMDF15 = FirstAMD,
   AMDZen,
@@ -205,7 +211,12 @@ struct PmuConfig {
 // See Intel 64 and IA32 Architectures Performance Monitoring Events.
 // See check_events from libpfm4.
 // Match order of CpuMicroarch.
+// For the Intel Core lineage, we use the name of the product rather than
+// the official name of the microarchitecture. For hybrid products the
+// data in this table is for the P-cores of that product. For E-cores
+// we use their actual Atom ("mont") microarchitecture.
 static const PmuConfig pmu_configs[] = {
+  { UnknownCpu, "Unknown", 0, 0, 0, 0, 0 },
   { IntelMerom, "Intel Merom", 0, 0, 0, 100, 0 },
   { IntelPenryn, "Intel Penryn", 0, 0, 0, 100, 0 },
   { IntelNehalem, "Intel Nehalem", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },
@@ -230,6 +241,9 @@ static const PmuConfig pmu_configs[] = {
   { IntelSilvermont, "Intel Silvermont", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },
   { IntelGoldmont, "Intel Goldmont", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },
   { IntelTremont, "Intel Tremont", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },
+  { IntelGracemont, "Intel Gracemont", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },
+  { IntelCrestmont, "Intel Crestmont", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },
+  { IntelSkymont, "Intel Skymont", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },
   { AMDF15, "AMD Family 15h", 0xc4, 0xc6, 0, 250, PMU_TICKS_TAKEN_BRANCHES },
   // 0xd1 == RETIRED_CONDITIONAL_BRANCH_INSTRUCTIONS - Number of retired conditional branch instructions
   // 0x2c == INTERRUPT_TAKEN - Counts the number of interrupts taken
@@ -460,6 +474,14 @@ static void do_branches() {
   accumulator_sink = accumulator;
 }
 
+struct CPUInfo {
+  // The microarch of the CPU core.
+  CpuMicroarch microarch;
+  // Either PERF_TYPE_RAW or some alternative type that should be used
+  // instead of PERF_TYPE_RAW for raw events on this core.
+  int raw_perf_event_type;
+};
+
 // Architecture specific detection code
 #if defined(__i386__) || defined(__x86_64__)
 #include "PerfCounters_x86.h"
@@ -469,7 +491,7 @@ static void do_branches() {
 #error Must define microarchitecture detection code for this architecture
 #endif
 
-static void check_working_counters(perf_event_attrs &perf_attr) {
+static void check_working_counters(perf_event_attrs &perf_attr, int pmu_index) {
   struct perf_event_attr attr = perf_attr.ticks;
   attr.sample_period = 0;
   struct perf_event_attr attr2 = perf_attr.cycles;
@@ -494,8 +516,9 @@ static void check_working_counters(perf_event_attrs &perf_attr) {
         << "\nGot " << events << " branch events, expected at least "
         << NUM_BRANCHES
         << ".\n"
-           "\nThe hardware performance counter seems to not be working. Check\n"
-           "that hardware performance counters are working by running\n"
+           "\nThe hardware performance counter seems to not be working on cpu "
+        << pmu_index << "\n"
+           "Check that hardware performance counters are working by running\n"
            "  "
         << perf_cmdline
         << "\n"
@@ -515,52 +538,59 @@ static void check_working_counters(perf_event_attrs &perf_attr) {
 }
 
 // Returns the ticks minimum period.
-static uint32_t check_for_bugs(perf_event_attrs &perf_attr) {
+// Must be run on the CPU that we're checking for bugs.
+static uint32_t check_for_bugs(perf_event_attrs &perf_attr, int pmu_index) {
   DEBUG_ASSERT(!running_under_rr());
   cpu_improperly_configured = false;
 
   uint32_t min_period = check_for_ioc_period_bug(perf_attr);
-  check_working_counters(perf_attr);
+  check_working_counters(perf_attr, pmu_index);
   check_for_arch_bugs(perf_attr);
   return min_period;
 }
 
-static std::vector<CpuMicroarch> get_cpu_microarchs() {
+static vector<CPUInfo> get_cpus_info() {
   string forced_uarch = lowercase(Flags::get().forced_uarch);
   if (!forced_uarch.empty()) {
     for (size_t i = 0; i < array_length(pmu_configs); ++i) {
       const PmuConfig& pmu = pmu_configs[i];
       string name = lowercase(pmu.name);
       if (name.npos != name.find(forced_uarch)) {
         LOG(info) << "Using forced uarch " << pmu.name;
-        return { pmu.uarch };
+        return {
+          { pmu.uarch, PERF_TYPE_RAW }
+        };
       }
     }
     CLEAN_FATAL() << "Forced uarch " << Flags::get().forced_uarch
                   << " isn't known.";
   }
-  return compute_cpu_microarchs();
+  return compute_cpus_info();
 }
 
 // Similar to rr::perf_attrs, if this contains more than one element,
 // it's indexed by the CPU index.
 static std::vector<PmuConfig> get_pmu_microarchs() {
   std::vector<PmuConfig> pmu_uarchs;
-  auto uarchs = get_cpu_microarchs();
+  auto cpus_info = get_cpus_info();
   bool found_working_pmu = false;
-  for (auto uarch : uarchs) {
+  for (const auto& info : cpus_info) {
     bool found = false;
-    for (size_t i = 0; i < array_length(pmu_configs); ++i) {
-      if (uarch == pmu_configs[i].uarch) {
+    for (const auto& pmu_config : pmu_configs) {
+      if (info.microarch == pmu_config.uarch) {
         found = true;
-        if (pmu_configs[i].flags & (PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES)) {
+        if (pmu_config.flags & (PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES)) {
           found_working_pmu |= true;
         }
-        pmu_uarchs.push_back(pmu_configs[i]);
+        pmu_uarchs.push_back(pmu_config);
+        pmu_uarchs.back().event_type = info.raw_perf_event_type;
         break;
       }
     }
-    DEBUG_ASSERT(found);
+    if (!found) {
+      FATAL() << "Can't find PMU config for " << info.microarch;
+    }
+    LOG(info) << "Found PMU config for " << info.microarch;
   }
   if (!found_working_pmu) {
     CLEAN_FATAL() << "No supported microarchitectures found.";
@@ -634,8 +664,7 @@ static void init_attributes() {
   }
 }
 
-bool PerfCounters::support_cpu(int cpu)
-{
+bool PerfCounters::support_cpu(int cpu) {
   // We could probably make cpu=-1 mean whether all CPUs are supported
   // if there's a need for it...
   DEBUG_ASSERT(cpu >= 0);
@@ -665,7 +694,14 @@ static void check_pmu(int pmu_index) {
     return;
   }
 
-  perf_attr.ticks_min_period = check_for_bugs(perf_attr);
+  if (perf_attrs.size() > 1 && !CPUs::set_affinity_to_cpu(pmu_index)) {
+    FATAL() << "Couldn't set affinity to the right PMU";
+  }
+  perf_attr.ticks_min_period = check_for_bugs(perf_attr, pmu_index);
+  if (perf_attrs.size() > 1) {
+    CPUs::get().restore_initial_affinity();
+  }
+
   /*
    * For maintainability, and since it doesn't impact performance when not
    * needed, we always activate this. If it ever turns out to be a problem,
@@ -944,7 +980,7 @@ void PerfCounters::start(Task* t, Ticks ticks_period) {
     }
 
     if (!perf_attr.only_one_counter && !running_under_rr()) {
-      reset_arch_extras<NativeArch>();
+      reset_arch_extras<NativeArch>(pmu_index);
     }
 
     if (perf_attr.activate_useless_counter && !fd_useless_counter.is_open()) {

src/PerfCounters.h

@@ -199,7 +199,7 @@ class PerfCounters {
 #endif
 
 private:
-  template <typename Arch> void reset_arch_extras();
+  template <typename Arch> void reset_arch_extras(int pmu_index);
 
   /**
    * Use a separate skid_size for recording since we seem to see more skid

src/PerfCounters_aarch64.h

@@ -256,8 +256,9 @@ static inline void get_cpuinfo_procfs(std::vector<CPUID> &res)
   reset();
 }
 
-static std::vector<CpuMicroarch> compute_cpu_microarchs() {
-  std::vector<CPUID> cpuids;
+static vector<CPUInfo> compute_cpus_info() {
+  vector<CPUInfo> result;
+  vector<CPUID> cpuids;
   get_cpuinfo_sysfs(cpuids);
   if (cpuids.empty()) {
     LOG(warn) << "Unable to read CPU type from sysfs, trying procfs instead.";
@@ -280,13 +281,13 @@ static std::vector<CpuMicroarch> compute_cpu_microarchs() {
     }
   }
   if (single_uarch) {
-    return { compute_cpu_microarch(cpuid0) };
+    result.push_back({compute_cpu_microarch(cpuid0), PERF_TYPE_RAW});
+    return result;
   }
-  std::vector<CpuMicroarch> uarchs;
   for (auto &cpuid : cpuids) {
-    uarchs.push_back(compute_cpu_microarch(cpuid));
+    result.push_back({compute_cpu_microarch(cpuid), PERF_TYPE_RAW});
   }
-  return uarchs;
+  return result;
 }
 
 static void arch_check_restricted_counter() {
@@ -405,7 +406,7 @@ static void post_init_pmu_uarchs(std::vector<PmuConfig> &pmu_uarchs)
 }
 
 template <>
-void PerfCounters::reset_arch_extras<ARM64Arch>() {
+void PerfCounters::reset_arch_extras<ARM64Arch>(int pmu_index) {
   // LL/SC can't be recorded reliably. Start a counter to detect
   // any usage, such that we can give an intelligent error message.
   struct perf_event_attr attr = perf_attrs[pmu_index].llsc_fail;