[llvm-exegesis] Output the unscaled value as well as the scaled one.

[courbet]

Summary

See PR38936 for context.

[courbet]

remve irrelevant file

[courbet]

fix field order

[gchatelet]

tools/llvm-exegesis/lib/BenchmarkResult.h

43

PerInstructionValue

45

SnippetValue

tools/llvm-exegesis/lib/BenchmarkRunner.cpp

93

Can you assert that InstrBenchmark.NumRepetitions!=0?

[courbet]

better field names

[courbet]

add assert

[courbet]

Thanks, PTAL.

[gchatelet]

tools/llvm-exegesis/lib/BenchmarkResult.cpp

301

As discussed let's rename the class something like BenchmarkMeasurePerInstructionsStats

[courbet]

s/BenchmarkMeasureStats/PerInstructionStats/

[courbet]

rebase

test/tools/llvm-exegesis/X86/latency-by-opcode-name.s

 # RUN: llvm-exegesis -mode=latency -opcode-name=ADD32rr | FileCheck %s
 
 CHECK:      mode:            latency
-CHECK-NEXT: key:
+CHECK: key:
 CHECK-NEXT:   instructions:
 CHECK-NEXT:     ADD32rr

tools/llvm-exegesis/lib/Analysis.cpp

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   const llvm::MCSchedClassDesc *const SCDesc =
       SchedModel.getSchedClassDesc(SchedClassId);
   writeEscaped<kEscapeCsv>(OS, SCDesc->Name);
 #else
   OS << SchedClassId;
 #endif
   for (const auto &Measurement : Point.Measurements) {
     OS << kCsvSep;
-    writeMeasurementValue<kEscapeCsv>(OS, Measurement.Value);
+    writeMeasurementValue<kEscapeCsv>(OS, Measurement.PerInstructionValue);
   }
   OS << "\n";
 }
 
 Analysis::Analysis(const llvm::Target &Target,
                    const InstructionBenchmarkClustering &Clustering)
     : Clustering_(Clustering) {
   if (Clustering.getPoints().empty())
bool Analysis::SchedClassCluster::measurementsMatch(
   if (Mode == InstructionBenchmark::Latency) {
     if (NumMeasurements != 1) {
       llvm::errs()
           << "invalid number of measurements in latency mode: expected 1, got "
           << NumMeasurements << "\n";
       return false;
     }
     // Find the latency.
-    SchedClassPoint[0].Value = 0.0;
+    SchedClassPoint[0].PerInstructionValue = 0.0;
     for (unsigned I = 0; I < SC.SCDesc->NumWriteLatencyEntries; ++I) {
       const llvm::MCWriteLatencyEntry *const WLE =
           STI.getWriteLatencyEntry(SC.SCDesc, I);
-      SchedClassPoint[0].Value =
-          std::max<double>(SchedClassPoint[0].Value, WLE->Cycles);
+      SchedClassPoint[0].PerInstructionValue =
+          std::max<double>(SchedClassPoint[0].PerInstructionValue, WLE->Cycles);
     }
-    ClusterCenterPoint[0].Value = Representative[0].avg();
+    ClusterCenterPoint[0].PerInstructionValue = Representative[0].avg();
   } else if (Mode == InstructionBenchmark::Uops) {
     for (int I = 0, E = Representative.size(); I < E; ++I) {
       // Find the pressure on ProcResIdx `Key`.
       uint16_t ProcResIdx = 0;
       if (!llvm::to_integer(Representative[I].key(), ProcResIdx, 10)) {
         llvm::errs() << "expected ProcResIdx key, got "
                      << Representative[I].key() << "\n";
         return false;
       }
       const auto ProcResPressureIt =
           std::find_if(SC.IdealizedProcResPressure.begin(),
                        SC.IdealizedProcResPressure.end(),
                        [ProcResIdx](const std::pair<uint16_t, float> &WPR) {
                          return WPR.first == ProcResIdx;
                        });
-      SchedClassPoint[I].Value =
+      SchedClassPoint[I].PerInstructionValue =
           ProcResPressureIt == SC.IdealizedProcResPressure.end()
               ? 0.0
               : ProcResPressureIt->second;
-      ClusterCenterPoint[I].Value = Representative[I].avg();
+      ClusterCenterPoint[I].PerInstructionValue = Representative[I].avg();
     }
   } else {
     llvm::errs() << "unimplemented measurement matching for mode " << Mode
                  << "\n";
     return false;
   }
   return Clustering.isNeighbour(ClusterCenterPoint, SchedClassPoint);
 }

tools/llvm-exegesis/lib/BenchmarkResult.h

struct InstructionBenchmarkKey {
   std::vector<llvm::MCInst> Instructions;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
 };
 
 struct BenchmarkMeasure {
   std::string Key;
-  double Value;
+  // 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;
   std::string DebugString;
 };
 
 // The result of an instruction benchmark.
 struct InstructionBenchmark {
   InstructionBenchmarkKey Key;
   enum ModeE { Unknown, Latency, Uops };
   ModeE Mode;

tools/llvm-exegesis/lib/BenchmarkResult.cpp

 template <> struct SequenceElementTraits<exegesis::BenchmarkMeasure> {
   static const bool flow = false;
 };
 
 // exegesis::Measure is rendererd as a flow instead of a list.
 // e.g. { "key": "the key", "value": 0123 }
 template <> struct MappingTraits<exegesis::BenchmarkMeasure> {
   static void mapping(IO &Io, exegesis::BenchmarkMeasure &Obj) {
-    Io.mapRequired("key", Obj.Key);
-    Io.mapRequired("value", Obj.Value);
     Io.mapOptional("debug_string", Obj.DebugString);
+    Io.mapRequired("value", Obj.PerInstructionValue);
+    Io.mapOptional("snippet_value", Obj.PerSnippetValue);
+    Io.mapRequired("key", Obj.Key);
   }
   static const bool flow = true;
 };
 
 template <>
 struct ScalarEnumerationTraits<exegesis::InstructionBenchmark::ModeE> {
   static void enumeration(IO &Io,
                           exegesis::InstructionBenchmark::ModeE &Value) {
if (auto E = llvm::errorCodeToError(
       return E;
     }
     llvm::raw_fd_ostream Ostr(ResultFD, true /*shouldClose*/);
     writeYamlTo(State, Ostr);
   }
   return llvm::Error::success();
 }
 
 void BenchmarkMeasureStats::push(const BenchmarkMeasure &BM) {
   if (Key.empty())
     Key = BM.Key;
   assert(Key == BM.Key);
   ++NumValues;
-  SumValues += BM.Value;
-  MaxValue = std::max(MaxValue, BM.Value);
-  MinValue = std::min(MinValue, BM.Value);
+  SumValues += BM.PerInstructionValue;
+  MaxValue = std::max(MaxValue, BM.PerInstructionValue);
+  MinValue = std::min(MinValue, BM.PerInstructionValue);
 }
 
 } // namespace exegesis

tools/llvm-exegesis/lib/BenchmarkRunner.h

private:
     char *const AlignedPtr;
   };
 
 protected:
   const LLVMState &State;
 
 private:
   virtual std::vector<BenchmarkMeasure>
-  runMeasurements(const ExecutableFunction &EF, ScratchSpace &Scratch,
-                  const unsigned NumRepetitions) const = 0;
+  runMeasurements(const ExecutableFunction &EF,
+                  ScratchSpace &Scratch) const = 0;
 
   llvm::Expected<std::string>
   writeObjectFile(const BenchmarkCode &Configuration,
                   llvm::ArrayRef<llvm::MCInst> Code) const;
 
   const InstructionBenchmark::ModeE Mode;
 
   const std::unique_ptr<ScratchSpace> Scratch;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRUNNER_H

tools/llvm-exegesis/lib/BenchmarkRunner.cpp

BenchmarkRunner::runConfiguration(const BenchmarkCode &BC,
   if (llvm::Error E = ObjectFilePath.takeError()) {
     InstrBenchmark.Error = llvm::toString(std::move(E));
     return InstrBenchmark;
   }
   llvm::outs() << "Check generated assembly with: /usr/bin/objdump -d "
                << *ObjectFilePath << "\n";
   const ExecutableFunction EF(State.createTargetMachine(),
                               getObjectFromFile(*ObjectFilePath));
-  InstrBenchmark.Measurements = runMeasurements(EF, *Scratch, NumRepetitions);
+  InstrBenchmark.Measurements = runMeasurements(EF, *Scratch);
+  assert(InstrBenchmark.NumRepetitions > 0 && "invalid NumRepetitions");
+  for (BenchmarkMeasure &BM : InstrBenchmark.Measurements) {
+    // Scale the measurements by instruction.
+    BM.PerInstructionValue /= InstrBenchmark.NumRepetitions;
+    // Scale the measurements by snippet.
+    BM.PerSnippetValue *= static_cast<double>(BC.Instructions.size()) /
+                   InstrBenchmark.NumRepetitions;
+  }
 
   return InstrBenchmark;
 }
 
 llvm::Expected<std::string>
 BenchmarkRunner::writeObjectFile(const BenchmarkCode &BC,
                                  llvm::ArrayRef<llvm::MCInst> Code) const {
   int ResultFD = 0;

tools/llvm-exegesis/lib/Clustering.cpp

InstructionBenchmarkClustering::rangeQuery(const size_t Q) const {
   return Neighbors;
 }
 
 bool InstructionBenchmarkClustering::isNeighbour(
     const std::vector<BenchmarkMeasure> &P,
     const std::vector<BenchmarkMeasure> &Q) const {
   double DistanceSquared = 0.0;
   for (size_t I = 0, E = P.size(); I < E; ++I) {
-    const auto Diff = P[I].Value - Q[I].Value;
+    const auto Diff = P[I].PerInstructionValue - Q[I].PerInstructionValue;
     DistanceSquared += Diff * Diff;
   }
   return DistanceSquared <= EpsilonSquared_;
 }
 
 InstructionBenchmarkClustering::InstructionBenchmarkClustering(
     const std::vector<InstructionBenchmark> &Points,
     const double EpsilonSquared)

tools/llvm-exegesis/lib/Latency.h

 class LatencyBenchmarkRunner : public BenchmarkRunner {
 public:
   LatencyBenchmarkRunner(const LLVMState &State)
       : BenchmarkRunner(State, InstructionBenchmark::Latency) {}
   ~LatencyBenchmarkRunner() override;
 
 private:
   std::vector<BenchmarkMeasure>
-  runMeasurements(const ExecutableFunction &EF, ScratchSpace &Scratch,
-                  const unsigned NumRepetitions) const override;
+  runMeasurements(const ExecutableFunction &EF,
+                  ScratchSpace &Scratch) const override;
 
   virtual const char *getCounterName() const;
 };
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LATENCY_H

tools/llvm-exegesis/lib/Latency.cpp

if (!CounterName)
     llvm::report_fatal_error("sched model does not define a cycle counter");
   return CounterName;
 }
 
 LatencyBenchmarkRunner::~LatencyBenchmarkRunner() = default;
 
 std::vector<BenchmarkMeasure>
 LatencyBenchmarkRunner::runMeasurements(const ExecutableFunction &Function,
-                                        ScratchSpace &Scratch,
-                                        const unsigned NumRepetitions) const {
+                                        ScratchSpace &Scratch) const {
   // Cycle measurements include some overhead from the kernel. Repeat the
   // measure several times and take the minimum value.
   constexpr const int NumMeasurements = 30;
   int64_t MinLatency = std::numeric_limits<int64_t>::max();
   const char *CounterName = getCounterName();
   if (!CounterName)
     llvm::report_fatal_error("could not determine cycle counter name");
   const pfm::PerfEvent CyclesPerfEvent(CounterName);
   if (!CyclesPerfEvent.valid())
     llvm::report_fatal_error("invalid perf event");
   for (size_t I = 0; I < NumMeasurements; ++I) {
     pfm::Counter Counter(CyclesPerfEvent);
     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) / NumRepetitions, ""}};
+  return {{"latency", static_cast<double>(MinLatency),
+           static_cast<double>(MinLatency), ""}};
 }
 
 } // namespace exegesis

tools/llvm-exegesis/lib/Uops.h

public:
   UopsBenchmarkRunner(const LLVMState &State)
       : BenchmarkRunner(State, InstructionBenchmark::Uops) {}
   ~UopsBenchmarkRunner() override;
 
   static constexpr const size_t kMinNumDifferentAddresses = 6;
 
 private:
   std::vector<BenchmarkMeasure>
-  runMeasurements(const ExecutableFunction &EF, ScratchSpace &Scratch,
-                  const unsigned NumRepetitions) const override;
+  runMeasurements(const ExecutableFunction &EF,
+                  ScratchSpace &Scratch) const override;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_UOPS_H

tools/llvm-exegesis/lib/Uops.cpp

CT.Info =
       "instruction has no tied variables picking Uses different from defs";
   CT.Instructions.push_back(std::move(IB));
   instantiateMemoryOperands(CT.ScratchSpacePointerInReg, CT.Instructions);
   return std::move(CT);
 }
 
 std::vector<BenchmarkMeasure>
 UopsBenchmarkRunner::runMeasurements(const ExecutableFunction &Function,
-                                     ScratchSpace &Scratch,
-                                     const unsigned NumRepetitions) const {
+                                     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)
for (const auto &CounterName : CounterNames) {
       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) / NumRepetitions,
+                      static_cast<double>(CounterValue),
+                      static_cast<double>(CounterValue),
                       SchedModel.getProcResource(ProcResIdx)->Name});
   }
   return Result;
 }
 
 constexpr const size_t UopsSnippetGenerator::kMinNumDifferentAddresses;
 
 } // namespace exegesis

unittests/tools/llvm-exegesis/ClusteringTest.cpp

 using testing::Field;
 using testing::UnorderedElementsAre;
 using testing::UnorderedElementsAreArray;
 
 TEST(ClusteringTest, Clusters3D) {
   std::vector<InstructionBenchmark> Points(6);
 
   // Cluster around (x=0, y=1, z=2): points {0, 3}.
-  Points[0].Measurements = {{"x", 0.01, ""}, {"y", 1.02, ""}, {"z", 1.98, "A"}};
-  Points[3].Measurements = {{"x", -0.01, ""}, {"y", 1.02, ""}, {"z", 1.98, ""}};
+  Points[0].Measurements = {
+      {"x", 0.01, 0.0, ""}, {"y", 1.02, 0.0, ""}, {"z", 1.98, 0.0, "A"}};
+  Points[3].Measurements = {
+      {"x", -0.01, 0.0, ""}, {"y", 1.02, 0.0, ""}, {"z", 1.98, 0.0, ""}};
   // Cluster around (x=1, y=1, z=2): points {1, 4}.
-  Points[1].Measurements = {{"x", 1.01, ""}, {"y", 1.02, ""}, {"z", 1.98, ""}};
-  Points[4].Measurements = {{"x", 0.99, ""}, {"y", 1.02, ""}, {"z", 1.98, ""}};
+  Points[1].Measurements = {
+      {"x", 1.01, 0.0, ""}, {"y", 1.02, 0.0, ""}, {"z", 1.98, 0.0, ""}};
+  Points[4].Measurements = {
+      {"x", 0.99, 0.0, ""}, {"y", 1.02, 0.0, ""}, {"z", 1.98, 0.0, ""}};
   // Cluster around (x=0, y=0, z=0): points {5}, marked as noise.
-  Points[5].Measurements = {{"x", 0.0, ""}, {"y", 0.01, ""}, {"z", -0.02, ""}};
+  Points[5].Measurements = {
+      {"x", 0.0, 0.0, ""}, {"y", 0.01, 0.0, ""}, {"z", -0.02, 0.0, ""}};
   // Error cluster: points {2}
   Points[2].Error = "oops";
 
   auto HasPoints = [](const std::vector<int> &Indices) {
     return Field(&InstructionBenchmarkClustering::Cluster::PointIndices,
                  UnorderedElementsAreArray(Indices));
   };
 
TEST(ClusteringTest, Clusters3D) {
   EXPECT_EQ(Clustering.get().getClusterIdForPoint(0),
             Clustering.get().getClusterIdForPoint(3));
   EXPECT_EQ(Clustering.get().getClusterIdForPoint(1),
             Clustering.get().getClusterIdForPoint(4));
 }
 
 TEST(ClusteringTest, Clusters3D_InvalidSize) {
   std::vector<InstructionBenchmark> Points(6);
-  Points[0].Measurements = {{"x", 0.01, ""}, {"y", 1.02, ""}, {"z", 1.98, ""}};
-  Points[1].Measurements = {{"y", 1.02, ""}, {"z", 1.98, ""}};
+  Points[0].Measurements = {
+      {"x", 0.01, 0.0, ""}, {"y", 1.02, 0.0, ""}, {"z", 1.98, 0.0, ""}};
+  Points[1].Measurements = {{"y", 1.02, 0.0, ""}, {"z", 1.98, 0.0, ""}};
   auto Error =
       InstructionBenchmarkClustering::create(Points, 2, 0.25).takeError();
   ASSERT_TRUE((bool)Error);
   consumeError(std::move(Error));
 }
 
 TEST(ClusteringTest, Clusters3D_InvalidOrder) {
   std::vector<InstructionBenchmark> Points(6);
-  Points[0].Measurements = {{"x", 0.01, ""}, {"y", 1.02, ""}};
-  Points[1].Measurements = {{"y", 1.02, ""}, {"x", 1.98, ""}};
+  Points[0].Measurements = {{"x", 0.01, 0.0, ""}, {"y", 1.02, 0.0, ""}};
+  Points[1].Measurements = {{"y", 1.02, 0.0, ""}, {"x", 1.98, 0.0, ""}};
   auto Error =
       InstructionBenchmarkClustering::create(Points, 2, 0.25).takeError();
   ASSERT_TRUE((bool)Error);
   consumeError(std::move(Error));
 }
 
 TEST(ClusteringTest, Ordering) {
   ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(1),

unittests/tools/llvm-exegesis/X86/BenchmarkResultTest.cpp

 using ::testing::Eq;
 using ::testing::get;
 using ::testing::Pointwise;
 using ::testing::Property;
 
 namespace exegesis {
 
 bool operator==(const BenchmarkMeasure &A, const BenchmarkMeasure &B) {
-  return std::tie(A.Key, A.Value) == std::tie(B.Key, B.Value);
+  return std::tie(A.Key, A.PerInstructionValue, A.PerSnippetValue) ==
+         std::tie(B.Key, B.PerInstructionValue, B.PerSnippetValue);
 }
 
 static std::string Dump(const llvm::MCInst &McInst) {
   std::string Buffer;
   llvm::raw_string_ostream OS(Buffer);
   McInst.print(OS);
   return Buffer;
 }
ToDisk.Key.Instructions.push_back(llvm::MCInstBuilder(llvm::X86::XOR32rr)
                                         .addReg(llvm::X86::AH)
                                         .addImm(123)
                                         .addFPImm(0.5));
   ToDisk.Key.Config = "config";
   ToDisk.Mode = InstructionBenchmark::Latency;
   ToDisk.CpuName = "cpu_name";
   ToDisk.LLVMTriple = "llvm_triple";
   ToDisk.NumRepetitions = 1;
-  ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, "debug a"});
-  ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, ""});
+  ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, 1, "debug a"});
+  ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, 2, ""});
   ToDisk.Error = "error";
   ToDisk.Info = "info";
 
   llvm::SmallString<64> Filename;
   std::error_code EC;
   EC = llvm::sys::fs::createUniqueDirectory("BenchmarkResultTestDir", Filename);
   ASSERT_FALSE(EC);
   llvm::sys::path::append(Filename, "data.yaml");
ExitOnErr(ToDisk.writeYaml(State, Filename));
     EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
     EXPECT_THAT(FromDisk.Error, ToDisk.Error);
     EXPECT_EQ(FromDisk.Info, ToDisk.Info);
   }
 }
 
 TEST(BenchmarkResultTest, BenchmarkMeasureStats) {
   BenchmarkMeasureStats Stats;
-  Stats.push(BenchmarkMeasure{"a", 0.5, "debug a"});
-  Stats.push(BenchmarkMeasure{"a", 1.5, "debug a"});
-  Stats.push(BenchmarkMeasure{"a", -1.0, "debug a"});
-  Stats.push(BenchmarkMeasure{"a", 0.0, "debug a"});
+  Stats.push(BenchmarkMeasure{"a", 0.5, 0.0, "debug a"});
+  Stats.push(BenchmarkMeasure{"a", 1.5, 0.0, "debug a"});
+  Stats.push(BenchmarkMeasure{"a", -1.0, 0.0, "debug a"});
+  Stats.push(BenchmarkMeasure{"a", 0.0, 0.0, "debug a"});
   EXPECT_EQ(Stats.min(), -1.0);
   EXPECT_EQ(Stats.max(), 1.5);
   EXPECT_EQ(Stats.avg(), 0.25); // (0.5+1.5-1.0+0.0) / 4
 }
 } // namespace
 } // namespace exegesis