[llvm-exegesis] Analysis: Show value extents.

[courbet]

Summary

Screenshot attached in phabricator.

[courbet]

[gchatelet]

tools/llvm-exegesis/lib/Analysis.cpp

203

Move this outside the loop then you can shorten MeasurementStats declaration.

210

As discussed let's use something like insert or push instead of accumulate.

[courbet]

s/accumulate/push

[courbet]

Thanks.

tools/llvm-exegesis/lib/Analysis.cpp

203

I varies in this loop :)

tools/llvm-exegesis/lib/Analysis.cpp

void Analysis::printSchedClassClustersHtml(std::vector<size_t> PointIds,
   }
   OS << "</tr>";
   for (size_t I = 0, E = PointIds.size(); I < E;) {
     const auto &CurrentClusterId =
         Clustering_.getClusterIdForPoint(PointIds[I]);
     OS << "<tr><td>";
     writeClusterId<kEscapeHtml>(OS, CurrentClusterId);
     OS << "</td><td><ul>";
-    const auto &ClusterRepresentative =
-        Points[PointIds[I]]; // FIXME: average measurements.
+    std::vector<BenchmarkMeasureStats> MeasurementStats(
+        Points[PointIds[I]].Measurements.size());
     for (; I < E &&
            Clustering_.getClusterIdForPoint(PointIds[I]) == CurrentClusterId;
          ++I) {
+      const auto &Point = Points[PointIds[I]];
       OS << "<li><span class=\"mono\">";
-      writeEscaped<kEscapeHtml>(OS, Points[PointIds[I]].Key.OpcodeName);
+      writeEscaped<kEscapeHtml>(OS, Point.Key.OpcodeName);
       OS << "</span> <span class=\"mono\">";
-      writeEscaped<kEscapeHtml>(OS, Points[PointIds[I]].Key.Config);
+      writeEscaped<kEscapeHtml>(OS, Point.Key.Config);
       OS << "</span></li>";
+      for (size_t J = 0, F = Point.Measurements.size(); J < F; ++J) {
+        MeasurementStats[J].accumulate(Point.Measurements[J]);
+      }
     }
     OS << "</ul></td>";
-    for (const auto &Measurement : ClusterRepresentative.Measurements) {
-      OS << "<td>";
-      writeMeasurementValue<kEscapeHtml>(OS, Measurement.Value);
-      OS << "</td>";
+    for (const auto &Stats : MeasurementStats) {
+      OS << "<td class=\"measurement\">";
+      writeMeasurementValue<kEscapeHtml>(OS, Stats.avg());
+      OS << "<br><span class=\"minmax\">[";
+      writeMeasurementValue<kEscapeHtml>(OS, Stats.min());
+      OS << ";";
+      writeMeasurementValue<kEscapeHtml>(OS, Stats.max());
+      OS << "]</span></td>";
     }
     OS << "</tr>";
   }
   OS << "</table>";
 }
 
 // Return the non-redundant list of WriteProcRes used by the given sched class.
 // The scheduling model for LLVM is such that each instruction has a certain
if (SCDesc.isValid()) {
     // WriteProcRes.
     OS << "<td><ul>";
     for (const auto &WPR :
          getNonRedundantWriteProcRes(SCDesc, *SubtargetInfo_)) {
       OS << "<li><span class=\"mono\">";
       writeEscaped<kEscapeHtml>(OS, SubtargetInfo_->getSchedModel()
                                         .getProcResource(WPR.ProcResourceIdx)
                                         ->Name);
-      OS << "</spam>: " << WPR.Cycles << "</li>";
+      OS << "</span>: " << WPR.Cycles << "</li>";
     }
     OS << "</ul></td>";
     OS << "</tr>";
   } else {
     OS << "<tr><td>&#10005;</td><td></td><td></td></tr>";
   }
   OS << "</table>";
 }
table.sched-class-desc td {
   padding-left: 10px;
   padding-right: 10px;
   padding-top: 2px;
   padding-bottom: 2px;
 }
 span.mono {
   font-family: monospace;
 }
+span.minmax {
+  color: #888;
+}
+td.measurement {
+  text-align: center;
+}
 </style>
 </head>
 )";
 
 template <>
 llvm::Error Analysis::run<Analysis::PrintSchedClassInconsistencies>(
     llvm::raw_ostream &OS) const {
   // Print the header.

tools/llvm-exegesis/lib/BenchmarkResult.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/YAMLTraits.h"
+#include <limits>
 #include <string>
 #include <vector>
 
 namespace exegesis {
 
 struct InstructionBenchmarkKey {
   // The LLVM opcode name.
   std::string OpcodeName;
struct InstructionBenchmark {
   readYamlsOrDie(llvm::StringRef Filename);
   void readYamlFrom(llvm::StringRef InputContent);
 
   // Write functions, non-const because of YAML traits.
   void writeYamlTo(llvm::raw_ostream &S);
   void writeYamlOrDie(const llvm::StringRef Filename);
 };
 
+//------------------------------------------------------------------------------
+// Utilities to work with Benchmark measures.
+
+// A class that measures stats over benchmark measures.
+class BenchmarkMeasureStats {
+public:
+  void accumulate(const BenchmarkMeasure &BM);
+
+  double avg() const {
+    assert(NumValues);
+    return SumValues / NumValues;
+  }
+  double min() const { return MinValue; }
+  double max() const { return MaxValue; }
+
+private:
+  std::string Key;
+  double SumValues = 0.0;
+  int NumValues = 0;
+  double MaxValue = std::numeric_limits<double>::min();
+  double MinValue = std::numeric_limits<double>::max();
+};
+
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H

tools/llvm-exegesis/lib/BenchmarkResult.cpp

if (Filename == "-") {
     int ResultFD = 0;
     llvm::cantFail(llvm::errorCodeToError(
         openFileForWrite(Filename, ResultFD, llvm::sys::fs::F_Text)));
     llvm::raw_fd_ostream Ostr(ResultFD, true /*shouldClose*/);
     writeYamlTo(Ostr);
   }
 }
 
+void BenchmarkMeasureStats::accumulate(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);
+}
+
 } // namespace exegesis

unittests/tools/llvm-exegesis/BenchmarkResultTest.cpp

ToDisk.writeYamlOrDie(Filename);
     EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
     EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
     EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
     EXPECT_THAT(FromDisk.Error, ToDisk.Error);
     EXPECT_EQ(FromDisk.Info, ToDisk.Info);
   }
 }
 
+TEST(BenchmarkResultTest, BenchmarkMeasureStats) {
+  BenchmarkMeasureStats Stats;
+  Stats.accumulate(BenchmarkMeasure{"a", 0.5, "debug a"});
+  Stats.accumulate(BenchmarkMeasure{"a", 1.5, "debug a"});
+  Stats.accumulate(BenchmarkMeasure{"a", -1.0, "debug a"});
+  Stats.accumulate(BenchmarkMeasure{"a", 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