Add flag to limit perf counters to main thread

Author: shreejaykurhade

docs/perf_counters.md

@@ -30,6 +30,10 @@ they are platform specific, but some (e.g. `CYCLES` or `INSTRUCTIONS`) are
 mapped by libpfm to platform-specifics - see libpfm
 [documentation](http://perfmon2.sourceforge.net/docs.html) for more details.
 
+By default, perf counters include work done by all benchmark-created threads.
+Pass `--benchmark_perf_counters_all_threads=false` to measure only the main
+benchmark thread.
+
 The counter values are reported back through the [User Counters](../README.md#custom-counters)
 mechanism, meaning, they are available in all the formats (e.g. JSON) supported
 by User Counters.

src/benchmark.cc

@@ -145,6 +145,9 @@ BM_DEFINE_bool(benchmark_counters_tabular, false);
 // information about libpfm: https://man7.org/linux/man-pages/man3/libpfm.3.html
 BM_DEFINE_string(benchmark_perf_counters, "");
 
+// Whether perf counters should include benchmark-created threads.
+BM_DEFINE_bool(benchmark_perf_counters_all_threads, true);
+
 // Extra context to include in the output formatted as comma-separated key-value
 // pairs. Kept internal as it's only used for parsing from env/command line.
 BM_DEFINE_kvpairs(benchmark_context, {});
@@ -427,8 +430,12 @@ void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
 
     // This perfcounters object needs to be created before the runners vector
     // below so it outlasts their lifetime.
-    PerfCountersMeasurement perfcounters(
-        StrSplit(FLAGS_benchmark_perf_counters, ','));
+    const std::vector<std::string> perf_counter_names =
+        StrSplit(FLAGS_benchmark_perf_counters, ',');
+    PerfCountersMeasurement perfcounters =
+        FLAGS_benchmark_perf_counters_all_threads
+            ? PerfCountersMeasurement(perf_counter_names)
+            : PerfCountersMeasurement::ForCurrentThread(perf_counter_names);
 
     // Vector of benchmarks to run
     std::vector<internal::BenchmarkRunner> runners;
@@ -457,7 +464,8 @@ void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
 
     // The use of performance counters with threads would be unintuitive for
     // the average user so we need to warn them about this case
-    if ((benchmarks_with_threads > 0) && (perfcounters.num_counters() > 0)) {
+    if ((benchmarks_with_threads > 0) && (perfcounters.num_counters() > 0) &&
+        FLAGS_benchmark_perf_counters_all_threads) {
       GetErrorLogInstance()
           << "***WARNING*** There are " << benchmarks_with_threads
           << " benchmarks with threads and " << perfcounters.num_counters()
@@ -783,6 +791,8 @@ void ParseCommandLineFlags(int* argc, char** argv) {
                       &FLAGS_benchmark_counters_tabular) ||
         ParseStringFlag(argv[i], "benchmark_perf_counters",
                         &FLAGS_benchmark_perf_counters) ||
+        ParseBoolFlag(argv[i], "benchmark_perf_counters_all_threads",
+                      &FLAGS_benchmark_perf_counters_all_threads) ||
         ParseKeyValueFlag(argv[i], "benchmark_context",
                           &FLAGS_benchmark_context) ||
         ParseStringFlag(argv[i], "benchmark_time_unit",
@@ -895,6 +905,7 @@ void PrintDefaultHelp() {
           "          [--benchmark_counters_tabular={true|false}]\n"
 #if defined HAVE_LIBPFM
           "          [--benchmark_perf_counters=<counter>,...]\n"
+          "          [--benchmark_perf_counters_all_threads={true|false}]\n"
 #endif
           "          [--benchmark_context=<key>=<value>,...]\n"
           "          [--benchmark_time_unit={ns|us|ms|s}]\n"

src/perf_counters.cc

@@ -135,7 +135,7 @@ static std::vector<uint64_t> GetPMUTypesForEvent(const perf_event_attr& attr) {
 }
 
 PerfCounters PerfCounters::Create(
-    const std::vector<std::string>& counter_names) {
+    const std::vector<std::string>& counter_names, Scope scope) {
   if (!counter_names.empty()) {
     Initialize();
   }
@@ -203,7 +203,7 @@ PerfCounters PerfCounters::Create(
     // read_format = PERF_FORMAT_GROUP don't work together, but that's not the
     // case.
     attr.disabled = is_first;
-    attr.inherit = true;
+    attr.inherit = (scope == Scope::kAllThreads);
     attr.pinned = is_first;
     attr.exclude_kernel = true;
     attr.exclude_user = false;
@@ -290,6 +290,16 @@ PerfCounters PerfCounters::Create(
                       std::move(leader_ids));
 }
 
+PerfCounters PerfCounters::Create(
+    const std::vector<std::string>& counter_names) {
+  return Create(counter_names, Scope::kAllThreads);
+}
+
+PerfCounters PerfCounters::CreateForCurrentThread(
+    const std::vector<std::string>& counter_names) {
+  return Create(counter_names, Scope::kCurrentThread);
+}
+
 void PerfCounters::CloseCounters() const {
   if (counter_ids_.empty()) {
     return;
@@ -318,6 +328,11 @@ PerfCounters PerfCounters::Create(
   return NoCounters();
 }
 
+PerfCounters PerfCounters::CreateForCurrentThread(
+    const std::vector<std::string>& counter_names) {
+  return Create(counter_names);
+}
+
 void PerfCounters::CloseCounters() const {}
 #endif  // defined HAVE_LIBPFM
 
@@ -327,6 +342,18 @@ PerfCountersMeasurement::PerfCountersMeasurement(
   counters_ = PerfCounters::Create(counter_names);
 }
 
+PerfCountersMeasurement::PerfCountersMeasurement(
+    const std::vector<std::string>& counter_names, PerfCounters&& counters)
+    : counters_(std::move(counters)),
+      start_values_(counter_names.size()),
+      end_values_(counter_names.size()) {}
+
+PerfCountersMeasurement PerfCountersMeasurement::ForCurrentThread(
+    const std::vector<std::string>& counter_names) {
+  return PerfCountersMeasurement(
+      counter_names, PerfCounters::CreateForCurrentThread(counter_names));
+}
+
 PerfCounters& PerfCounters::operator=(PerfCounters&& other) noexcept {
   if (this != &other) {
     CloseCounters();

src/perf_counters.h

@@ -117,6 +117,8 @@ class BENCHMARK_EXPORT PerfCounters final {
   // In case of failure, this method will in the worst case return an
   // empty object whose state will still be valid.
   static PerfCounters Create(const std::vector<std::string>& counter_names);
+  static PerfCounters CreateForCurrentThread(
+      const std::vector<std::string>& counter_names);
 
   // Take a snapshot of the current value of the counters into the provided
   // valid PerfCounterValues storage. The values are populated such that:
@@ -135,6 +137,11 @@ class BENCHMARK_EXPORT PerfCounters final {
   size_t num_counters() const { return counter_names_.size(); }
 
  private:
+  enum class Scope { kCurrentThread, kAllThreads };
+
+  static PerfCounters Create(const std::vector<std::string>& counter_names,
+                             Scope scope);
+
   PerfCounters(const std::vector<std::string>& counter_names,
                std::vector<int>&& counter_ids, std::vector<int>&& leader_ids)
       : counter_ids_(std::move(counter_ids)),
@@ -152,6 +159,8 @@ class BENCHMARK_EXPORT PerfCounters final {
 class BENCHMARK_EXPORT PerfCountersMeasurement final {
  public:
   PerfCountersMeasurement(const std::vector<std::string>& counter_names);
+  static PerfCountersMeasurement ForCurrentThread(
+      const std::vector<std::string>& counter_names);
 
   size_t num_counters() const { return counters_.num_counters(); }
 
@@ -187,6 +196,9 @@ class BENCHMARK_EXPORT PerfCountersMeasurement final {
   }
 
  private:
+  PerfCountersMeasurement(const std::vector<std::string>& counter_names,
+                          PerfCounters&& counters);
+
   PerfCounters counters_;
   bool valid_read_ = true;
   PerfCounterValues start_values_;