[llvm-exegesis] Add support for measuring NumMicroOps.

[courbet]

Summary

Example output for vzeroall:

---
mode:            uops
key:
  instructions:
    - 'VZEROALL'
  config:          ''
  register_initial_values:
cpu_name:        haswell
llvm_triple:     x86_64-unknown-linux-gnu
num_repetitions: 10000
measurements:
  - { debug_string: HWPort0, value: 0.0006, per_snippet_value: 0.0006,
      key: '3' }
  - { debug_string: HWPort1, value: 0.0011, per_snippet_value: 0.0011,
      key: '4' }
  - { debug_string: HWPort2, value: 0.0004, per_snippet_value: 0.0004,
      key: '5' }
  - { debug_string: HWPort3, value: 0.0018, per_snippet_value: 0.0018,
      key: '6' }
  - { debug_string: HWPort4, value: 0.0002, per_snippet_value: 0.0002,
      key: '7' }
  - { debug_string: HWPort5, value: 1.0019, per_snippet_value: 1.0019,
      key: '8' }
  - { debug_string: HWPort6, value: 1.0033, per_snippet_value: 1.0033,
      key: '9' }
  - { debug_string: HWPort7, value: 0.0001, per_snippet_value: 0.0001,
      key: '10' }
  - { debug_string: NumMicroOps, value: 20.0069, per_snippet_value: 20.0069,
      key: NumMicroOps }
error:           ''
info:            ''
assembled_snippet: C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C5FC77C3
...

[gchatelet]

tools/llvm-exegesis/lib/Uops.cpp

289 ↗

(On Diff #167087)

I'm not too fond of the initializer list here because it's not future proof (and not readable)
Maybe create a value on the stack, initializes the members and push_back(std::move())?

Same below.

294 ↗

(On Diff #167087)

Might be worth creating a variable for SchedModel.getExtraProcessorInfo().PfmCounters

[courbet]

address comments

llvm/trunk/include/llvm/MC/MCSchedule.h

struct MCExtraProcessorInfo {
   const MCRegisterCostEntry *RegisterCostTable;
   unsigned NumRegisterCostEntries;
 
   struct PfmCountersInfo {
     // An optional name of a performance counter that can be used to measure
     // cycles.
     const char *CycleCounter;
 
+    // An optional name of a performance counter that can be used to measure
+    // uops.
+    const char *UopsCounter;
+
     // For each MCProcResourceDesc defined by the processor, an optional list of
     // names of performance counters that can be used to measure the resource
     // utilization.
     const char **IssueCounters;
   };
   PfmCountersInfo PfmCounters;
 };
 

llvm/trunk/include/llvm/Target/TargetSchedule.td

 // a PfmIssueCounter.
 class PfmIssueCounter<ProcResourceUnits resource, list<string> counters>
     : PfmCounter{
   // The resource units on which uops are issued.
   ProcResourceUnits Resource = resource;
   // The list of counters that measure issue events.
   list<string> Counters = counters;
 }
+
+// Each processor can define how to measure NumMicroOps by defining a
+// PfmUopsCounter.
+class PfmUopsCounter<string counter> : PfmCounter {
+  string Counter = counter;
+}
+

llvm/trunk/lib/Target/X86/X86PfmCounters.td

 def HWPort0Counter : PfmIssueCounter<HWPort0, ["uops_dispatched_port:port_0"]>;
 def HWPort1Counter : PfmIssueCounter<HWPort1, ["uops_dispatched_port:port_1"]>;
 def HWPort2Counter : PfmIssueCounter<HWPort2, ["uops_dispatched_port:port_2"]>;
 def HWPort3Counter : PfmIssueCounter<HWPort3, ["uops_dispatched_port:port_3"]>;
 def HWPort4Counter : PfmIssueCounter<HWPort4, ["uops_dispatched_port:port_4"]>;
 def HWPort5Counter : PfmIssueCounter<HWPort5, ["uops_dispatched_port:port_5"]>;
 def HWPort6Counter : PfmIssueCounter<HWPort6, ["uops_dispatched_port:port_6"]>;
 def HWPort7Counter : PfmIssueCounter<HWPort7, ["uops_dispatched_port:port_7"]>;
+def HWUopsCounter  : PfmUopsCounter<"uops_issued:any">;
 }
 
 let SchedModel = BroadwellModel in {
 def BWCycleCounter : PfmCycleCounter<"unhalted_core_cycles">;
 def BWPort0Counter : PfmIssueCounter<BWPort0, ["uops_executed_port:port_0"]>;
 def BWPort1Counter : PfmIssueCounter<BWPort1, ["uops_executed_port:port_1"]>;
 def BWPort2Counter : PfmIssueCounter<BWPort2, ["uops_executed_port:port_2"]>;
 def BWPort3Counter : PfmIssueCounter<BWPort3, ["uops_executed_port:port_3"]>;

llvm/trunk/tools/llvm-exegesis/lib/BenchmarkResult.h

struct InstructionBenchmarkKey {
   // The initial values of the registers.
   std::vector<RegisterValue> RegisterInitialValues;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
 };
 
 struct BenchmarkMeasure {
+  // A helper to create an unscaled BenchmarkMeasure.
+  static BenchmarkMeasure Create(std::string Key, double Value) {
+    return {Key, Value, Value, Key};
+  }
   std::string Key;
   // This is the per-instruction value, i.e. measured quantity scaled per
   // instruction.
   double PerInstructionValue;
   // This is the per-snippet value, i.e. measured quantity for one repetition of
   // the whole snippet.
   double PerSnippetValue;
+  // FIXME: remove, use `Key` instead.
   std::string DebugString;
 };
 
 // The result of an instruction benchmark.
 struct InstructionBenchmark {
   InstructionBenchmarkKey Key;
   enum ModeE { Unknown, Latency, Uops };
   ModeE Mode;

llvm/trunk/tools/llvm-exegesis/lib/Latency.cpp

for (size_t I = 0; I < NumMeasurements; ++I) {
     Scratch.clear();
     Counter.start();
     Function(Scratch.ptr());
     Counter.stop();
     const int64_t Value = Counter.read();
     if (Value < MinLatency)
       MinLatency = Value;
   }
-  return {{"latency", static_cast<double>(MinLatency),
-           static_cast<double>(MinLatency), ""}};
+  return {BenchmarkMeasure::Create("latency", MinLatency)};
 }
 
 } // namespace exegesis

llvm/trunk/tools/llvm-exegesis/lib/Uops.cpp

UopsSnippetGenerator::generateCodeTemplate(unsigned Opcode) const {
   return std::move(CT);
 }
 
 std::vector<BenchmarkMeasure>
 UopsBenchmarkRunner::runMeasurements(const ExecutableFunction &Function,
                                      ScratchSpace &Scratch) const {
   const auto &SchedModel = State.getSubtargetInfo().getSchedModel();
 
-  std::vector<BenchmarkMeasure> Result;
-  for (unsigned ProcResIdx = 1;
-       ProcResIdx < SchedModel.getNumProcResourceKinds(); ++ProcResIdx) {
-    const char *const PfmCounters = SchedModel.getExtraProcessorInfo()
-                                        .PfmCounters.IssueCounters[ProcResIdx];
-    if (!PfmCounters)
-      continue;
+  const auto RunMeasurement = [&Function,
+                               &Scratch](const char *const Counters) {
     // We sum counts when there are several counters for a single ProcRes
     // (e.g. P23 on SandyBridge).
     int64_t CounterValue = 0;
     llvm::SmallVector<llvm::StringRef, 2> CounterNames;
-    llvm::StringRef(PfmCounters).split(CounterNames, ',');
+    llvm::StringRef(Counters).split(CounterNames, ',');
     for (const auto &CounterName : CounterNames) {
       pfm::PerfEvent UopPerfEvent(CounterName);
       if (!UopPerfEvent.valid())
         llvm::report_fatal_error(
-            llvm::Twine("invalid perf event ").concat(PfmCounters));
+            llvm::Twine("invalid perf event ").concat(Counters));
       pfm::Counter Counter(UopPerfEvent);
       Scratch.clear();
       Counter.start();
       Function(Scratch.ptr());
       Counter.stop();
       CounterValue += Counter.read();
     }
-    Result.push_back({llvm::itostr(ProcResIdx),
-                      static_cast<double>(CounterValue),
-                      static_cast<double>(CounterValue),
-                      SchedModel.getProcResource(ProcResIdx)->Name});
+    return CounterValue;
+  };
+
+  std::vector<BenchmarkMeasure> Result;
+  const auto& PfmCounters = SchedModel.getExtraProcessorInfo().PfmCounters;
+  // Uops per port.
+  for (unsigned ProcResIdx = 1;
+       ProcResIdx < SchedModel.getNumProcResourceKinds(); ++ProcResIdx) {
+    const char *const Counters = PfmCounters.IssueCounters[ProcResIdx];
+    if (!Counters)
+      continue;
+    const double CounterValue = RunMeasurement(Counters);
+    Result.push_back(BenchmarkMeasure::Create(SchedModel.getProcResource(ProcResIdx)->Name, CounterValue));
+  }
+  // NumMicroOps.
+  if (const char *const UopsCounter = PfmCounters.UopsCounter) {
+    const double CounterValue = RunMeasurement(UopsCounter);
+    Result.push_back(BenchmarkMeasure::Create("NumMicroOps", CounterValue));
   }
   return Result;
 }
 
 constexpr const size_t UopsSnippetGenerator::kMinNumDifferentAddresses;
 
 } // namespace exegesis

llvm/trunk/utils/TableGen/CodeGenSchedule.h

struct CodeGenProcModel {
   std::vector<CodeGenRegisterFile> RegisterFiles;
 
   // Optional Retire Control Unit definition.
   Record *RetireControlUnit;
 
   // List of PfmCounters.
   RecVec PfmIssueCounterDefs;
   Record *PfmCycleCounterDef = nullptr;
+  Record *PfmUopsCounterDef = nullptr;
 
   CodeGenProcModel(unsigned Idx, std::string Name, Record *MDef,
                    Record *IDef) :
     Index(Idx), ModelName(std::move(Name)), ModelDef(MDef), ItinsDef(IDef),
     RetireControlUnit(nullptr) {}
 
   bool hasItineraries() const {
     return !ItinsDef->getValueAsListOfDefs("IID").empty();
   }
 
   bool hasInstrSchedModel() const {
     return !WriteResDefs.empty() || !ItinRWDefs.empty();
   }
 
   bool hasExtraProcessorInfo() const {
     return RetireControlUnit || !RegisterFiles.empty() ||
         !PfmIssueCounterDefs.empty() ||
-        PfmCycleCounterDef != nullptr;
+        PfmCycleCounterDef != nullptr ||
+        PfmUopsCounterDef != nullptr;
   }
 
   unsigned getProcResourceIdx(Record *PRDef) const;
 
   bool isUnsupported(const CodeGenInstruction &Inst) const;
 
 #ifndef NDEBUG
   void dump() const;

llvm/trunk/utils/TableGen/CodeGenSchedule.cpp

for (Record *Def : Records.getAllDerivedDefinitions("PfmCycleCounter")) {
     CodeGenProcModel &PM = getProcModel(Def->getValueAsDef("SchedModel"));
     if (PM.PfmCycleCounterDef) {
       PrintFatalError(Def->getLoc(),
                       "multiple cycle counters for " +
                           Def->getValueAsDef("SchedModel")->getName());
     }
     PM.PfmCycleCounterDef = Def;
   }
+  for (Record *Def : Records.getAllDerivedDefinitions("PfmUopsCounter")) {
+    CodeGenProcModel &PM = getProcModel(Def->getValueAsDef("SchedModel"));
+    if (PM.PfmUopsCounterDef) {
+      PrintFatalError(Def->getLoc(),
+                      "multiple uops counters for " +
+                          Def->getValueAsDef("SchedModel")->getName());
+    }
+    PM.PfmUopsCounterDef = Def;
+  }
 }
 
 // Collect and sort WriteRes, ReadAdvance, and ProcResources.
 void CodeGenSchedModels::collectProcResources() {
   ProcResourceDefs = Records.getAllDerivedDefinitions("ProcResourceUnits");
   ProcResGroups = Records.getAllDerivedDefinitions("ProcResGroup");
 
   // Add any subtarget-specific SchedReadWrites that are directly associated

llvm/trunk/utils/TableGen/SubtargetEmitter.cpp

static void EmitPfmCounters(const CodeGenProcModel &ProcModel,
   OS << "  {\n";
   // Emit the cycle counter.
   if (ProcModel.PfmCycleCounterDef)
     OS << "    \"" << ProcModel.PfmCycleCounterDef->getValueAsString("Counter")
        << "\",  // Cycle counter.\n";
   else
     OS << "    nullptr,  // No cycle counter.\n";
 
+  // Emit the uops counter.
+  if (ProcModel.PfmUopsCounterDef)
+    OS << "    \"" << ProcModel.PfmUopsCounterDef->getValueAsString("Counter")
+       << "\",  // Uops counter.\n";
+  else
+    OS << "    nullptr,  // No uops counter.\n";
+
   // Emit a reference to issue counters table.
   if (HasPfmIssueCounters)
     OS << "    " << ProcModel.ModelName << "PfmIssueCounters\n";
   else
     OS << "    nullptr  // No issue counters.\n";
   OS << "  }\n";
 }