By default, prefer to record on P-cores, but provide an option to disable that preference.

This cleans up the CPU-binding API by making `BindCPU` a proper type with an enum
for the various cases we support.

Author: rocallahan

src/CPUs.cc

@@ -5,12 +5,113 @@
 #include <sched.h>
 #include <unistd.h>
 
+#include <filesystem>
+#include <fstream>
+#include <istream>
+#include <sstream>
+#include <string>
+
 #include "log.h"
 
 using namespace std;
 
 namespace rr {
 
+static bool hybrid_cpu_arch_parse_cpus(const filesystem::path& dir,
+                                       CPUGroup* group) {
+  ifstream file(dir / "cpus");
+  if (!file.good()) {
+    LOG(warn) << "File " << dir.string() << "/cpus not found";
+    return false;
+  }
+  ostringstream sstr;
+  sstr << file.rdbuf();
+  string s = sstr.str();
+  while (!s.empty() && s[s.size() - 1] == '\n') {
+    s.resize(s.size() - 1);
+  }
+  size_t dash = s.find('-');
+  if (dash == string::npos) {
+    size_t end;
+    group->start_cpu = stoi(s, &end);
+    if (end != s.size()) {
+      LOG(warn) << "Bad CPU index";
+      return false;
+    }
+    group->end_cpu = group->start_cpu + 1;
+    return true;
+  }
+  size_t end;
+  group->start_cpu = stoi(s.substr(0, dash), &end);
+  if (end != dash) {
+    LOG(warn) << "Bad CPU index";
+    return false;
+  }
+  int last_cpu = stoi(s.substr(dash + 1), &end);
+  if (end != s.size() - (dash + 1)) {
+    LOG(warn) << "Bad end CPU index";
+    return false;
+  }
+  group->end_cpu = last_cpu + 1;
+  return true;
+}
+
+static bool hybrid_cpu_arch_parse_type(const filesystem::path& dir,
+                                       CPUGroup* group) {
+  // See https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/intel-hybrid.txt
+  ifstream file(dir / "type");
+  if (!file.good()) {
+    LOG(warn) << "File " << dir.string() << "/type not found";
+    return false;
+  }
+  ostringstream sstr;
+  sstr << file.rdbuf();
+  string s = sstr.str();
+  while (!s.empty() && s[s.size() - 1] == '\n') {
+    s.resize(s.size() - 1);
+  }
+  size_t end;
+  group->type = stoi(s, &end);
+  if (end != s.size()) {
+    LOG(warn) << "Bad type";
+    return false;
+  }
+  return true;
+}
+
+// Returns an empty list on many (all?) systems that aren't using hybrid cores.
+// In that case, assume all CPUs have the same microarch.
+static vector<CPUGroup> hybrid_cpu_arch_groups() {
+  vector<CPUGroup> result;
+  filesystem::path dir_path = "/sys/devices";
+  if (!filesystem::is_directory(dir_path)) {
+    return result;
+  }
+  for (const auto& entry : filesystem::directory_iterator(dir_path)) {
+    auto file_name = entry.path().filename().string();
+    if (file_name.find("cpu_") != 0) {
+      continue;
+    }
+    CPUGroup group;
+    group.name = file_name.substr(4);
+    if (!hybrid_cpu_arch_parse_cpus(entry.path(), &group)) {
+      continue;
+    }
+    if (!hybrid_cpu_arch_parse_type(entry.path(), &group)) {
+      continue;
+    }
+    if (group.name == "core") {
+      group.kind = CPUGroup::P_CORE;
+    } else if (group.name == "atom" || group.name == "lowpower") {
+      group.kind = CPUGroup::E_CORE;
+    } else {
+      group.kind = CPUGroup::UNKNOWN;
+    }
+    result.push_back(std::move(group));
+  }
+  return result;
+}
+
 const CPUs& CPUs::get() {
   static CPUs singleton;
   return singleton;
@@ -56,6 +157,7 @@ CPUs::CPUs() {
   if (ret < 0) {
     FATAL() << "failed to get initial affinity";
   }
+  cpu_groups_ = hybrid_cpu_arch_groups();
 }
 
 }

src/CPUs.h

@@ -5,10 +5,44 @@
 
 #include <sched.h>
 
+#include <string>
 #include <vector>
 
 namespace rr {
 
+struct BindCPU {
+  enum Mode {
+    // Bind to any core.
+    ANY,
+    // Perfer high-performance core if CPU affinity settings allow.
+    PREFER_PERF_CORE,
+    // Bind to a specified core unconditionally.
+    SPECIFIED_CORE,
+    // Don't bind.
+    UNBOUND,
+  };
+
+  explicit BindCPU(Mode mode) : mode(mode) {}
+  explicit BindCPU(int specified_core)
+    : mode(SPECIFIED_CORE), specified_core(specified_core) {}
+
+  Mode mode;
+  int specified_core;
+};
+
+struct CPUGroup {
+  enum Kind { P_CORE, E_CORE, UNKNOWN };
+
+  int start_cpu;
+  // Exclusive
+  int end_cpu;
+  std::string name;
+  // PERF_TYPE_RAW or something else usable in the perf-attr
+  // event_type field.
+  int type;
+  Kind kind;
+};
+
 class CPUs {
 public:
   static const CPUs& get();
@@ -20,10 +54,15 @@ class CPUs {
   // If unspecified, defaults to this thread.
   void restore_initial_affinity(pid_t tid = 0) const;
 
+  // Returns the CPU group list. May be empty on systems where that
+  // information is not available or relevant.
+  const std::vector<CPUGroup>& cpu_groups() const { return cpu_groups_; }
+
 private:
   CPUs();
 
   cpu_set_t initial_affinity_;
+  std::vector<CPUGroup> cpu_groups_;
 };
 
 }

src/DiversionSession.cc

@@ -14,7 +14,7 @@ using namespace std;
 
 namespace rr {
 
-DiversionSession::DiversionSession(int cpu_binding) :
+DiversionSession::DiversionSession(BindCPU cpu_binding) :
   emu_fs(EmuFs::create()), fake_timer_counter(uint64_t(1) << 60), cpu_binding_(cpu_binding) {}
 
 DiversionSession::~DiversionSession() {

src/DiversionSession.h

@@ -29,7 +29,7 @@ class ReplaySession;
  */
 class DiversionSession final : public Session {
 public:
-  DiversionSession(int cpu_binding);
+  DiversionSession(BindCPU cpu_binding);
 
   typedef std::shared_ptr<DiversionSession> shr_ptr;
 
@@ -54,7 +54,7 @@ class DiversionSession final : public Session {
                                  int signal_to_deliver = 0);
 
   virtual DiversionSession* as_diversion() override { return this; }
-  virtual int cpu_binding() const override { return cpu_binding_; }
+  virtual BindCPU cpu_binding() const override { return cpu_binding_; }
 
   void set_tracee_fd_number(int fd_number) { tracee_socket_fd_number = fd_number; }
   void on_create(Task *t) override { this->Session::on_create(t); }
@@ -66,7 +66,7 @@ class DiversionSession final : public Session {
 
   std::shared_ptr<EmuFs> emu_fs;
   uint64_t fake_timer_counter;
-  int cpu_binding_;
+  BindCPU cpu_binding_;
 };
 
 } // namespace rr

src/PerfCounters.cc

@@ -23,9 +23,7 @@
 #endif
 
 #include <algorithm>
-#include <filesystem>
 #include <fstream>
-#include <sstream>
 #include <limits>
 #include <regex>
 #include <string>
@@ -316,24 +314,28 @@ static string lowercase(const string& s) {
 // The index of the PMU we are using within perf_attrs.
 // This is always 0 if we detected a single PMU type
 // and will be the same as the CPU index if we detected multiple PMU types.
-static int get_pmu_index(int cpu_binding) {
-  if (cpu_binding < 0) {
+static int get_pmu_index(BindCPU cpu_binding) {
+  if (cpu_binding.mode == BindCPU::UNBOUND) {
     if (perf_attrs.size() > 1) {
       CLEAN_FATAL() << "\nMultiple PMU types detected. Unbinding CPU is not supported.";
     }
     return 0;
   }
-  if (!PerfCounters::support_cpu(cpu_binding)) {
-    CLEAN_FATAL() << "\nPMU on cpu " << cpu_binding << " is not supported.";
+  if (cpu_binding.mode != BindCPU::SPECIFIED_CORE) {
+    FATAL() << "Only specified-core mode supported at this point";
+  }
+  int cpu = cpu_binding.specified_core;
+  if (!PerfCounters::support_cpu(cpu)) {
+    CLEAN_FATAL() << "\nPMU on cpu " << cpu << " is not supported.";
   }
   if (perf_attrs.size() == 1) {
     // Single PMU type.
     return 0;
   }
-  if ((size_t)cpu_binding >= perf_attrs.size()) {
-    CLEAN_FATAL() << "\nUnable to find PMU type for CPU " << cpu_binding;
+  if ((size_t)cpu >= perf_attrs.size()) {
+    CLEAN_FATAL() << "\nUnable to find PMU type for CPU " << cpu;
   }
-  return cpu_binding;
+  return cpu;
 }
 
 static void init_perf_event_attr(struct perf_event_attr* attr,
@@ -755,7 +757,7 @@ uint32_t PerfCounters::skid_size() {
       perf_attrs[pmu_index].ticks_min_period;
 }
 
-PerfCounters::PerfCounters(pid_t tid, int cpu_binding,
+PerfCounters::PerfCounters(pid_t tid, BindCPU cpu_binding,
                            TicksSemantics ticks_semantics, Enabled enabled,
                            IntelPTEnabled enable_pt)
     : tid(tid), pmu_index(get_pmu_index(cpu_binding)), ticks_semantics_(ticks_semantics),

src/PerfCounters.h

@@ -16,6 +16,7 @@
 #include <utility>
 #include <vector>
 
+#include "CPUs.h"
 #include "PerfCounterBuffers.h"
 #include "ScopedFd.h"
 #include "Ticks.h"
@@ -64,7 +65,8 @@ class PerfCounters {
     PT_DISABLE,
     PT_ENABLE
   };
-  PerfCounters(pid_t tid, int cpu_binding, TicksSemantics ticks_semantics,
+  // `cpu_binding` must be `UNBOUND` or `SPECIFIED_CORE`.
+  PerfCounters(pid_t tid, BindCPU cpu_binding, TicksSemantics ticks_semantics,
                Enabled enabled, IntelPTEnabled enable_pt);
   ~PerfCounters() { close(); }
 

src/PerfCounters_x86.h

@@ -176,105 +176,9 @@ static CpuMicroarch compute_cpu_microarch() {
   return UnknownCpu; // not reached
 }
 
-struct CPUGroup {
-  int start_cpu;
-  // Exclusive
-  int end_cpu;
-  string name;
-  int type;
-};
-
-static bool hybrid_cpu_arch_parse_cpus(const filesystem::path& dir,
-                                       CPUGroup* group) {
-  ifstream file(dir / "cpus");
-  if (!file.good()) {
-    LOG(warn) << "File " << dir.string() << "/cpus not found";
-    return false;
-  }
-  ostringstream sstr;
-  sstr << file.rdbuf();
-  string s = sstr.str();
-  while (!s.empty() && s[s.size() - 1] == '\n') {
-    s.resize(s.size() - 1);
-  }
-  size_t dash = s.find('-');
-  if (dash == string::npos) {
-    size_t end;
-    group->start_cpu = stoi(s, &end);
-    if (end != s.size()) {
-      LOG(warn) << "Bad CPU index";
-      return false;
-    }
-    group->end_cpu = group->start_cpu + 1;
-    return true;
-  }
-  size_t end;
-  group->start_cpu = stoi(s.substr(0, dash), &end);
-  if (end != dash) {
-    LOG(warn) << "Bad CPU index";
-    return false;
-  }
-  int last_cpu = stoi(s.substr(dash + 1), &end);
-  if (end != s.size() - (dash + 1)) {
-    LOG(warn) << "Bad end CPU index";
-    return false;
-  }
-  group->end_cpu = last_cpu + 1;
-  return true;
-}
-
-static bool hybrid_cpu_arch_parse_type(const filesystem::path& dir,
-                                       CPUGroup* group) {
-  // See https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/intel-hybrid.txt
-  ifstream file(dir / "type");
-  if (!file.good()) {
-    LOG(warn) << "File " << dir.string() << "/type not found";
-    return false;
-  }
-  ostringstream sstr;
-  sstr << file.rdbuf();
-  string s = sstr.str();
-  while (!s.empty() && s[s.size() - 1] == '\n') {
-    s.resize(s.size() - 1);
-  }
-  size_t end;
-  group->type = stoi(s, &end);
-  if (end != s.size()) {
-    LOG(warn) << "Bad type";
-    return false;
-  }
-  return true;
-}
-
-// Returns an empty list on many (all?) systems that aren't using hybrid cores.
-// In that case, assume all CPUs have the same microarch.
-static vector<CPUGroup> hybrid_cpu_arch_groups() {
-  vector<CPUGroup> result;
-  filesystem::path dir_path = "/sys/devices";
-  if (!filesystem::is_directory(dir_path)) {
-    return result;
-  }
-  for (const auto& entry : filesystem::directory_iterator(dir_path)) {
-    auto file_name = entry.path().filename().string();
-    if (file_name.find("cpu_") != 0) {
-      continue;
-    }
-    CPUGroup group;
-    group.name = file_name.substr(4);
-    if (!hybrid_cpu_arch_parse_cpus(entry.path(), &group)) {
-      continue;
-    }
-    if (!hybrid_cpu_arch_parse_type(entry.path(), &group)) {
-      continue;
-    }
-    result.push_back(std::move(group));
-  }
-  return result;
-}
-
 static vector<CPUInfo> compute_cpus_info() {
   vector<CPUInfo> result;
-  auto groups = hybrid_cpu_arch_groups();
+  auto groups = CPUs::get().cpu_groups();
   if (groups.empty()) {
     // Only one kind of CPU core.
     result.push_back({compute_cpu_microarch(), PERF_TYPE_RAW});