[llvm-exegesis] Show noise cluster in analysis output.

[courbet]

[gchatelet]

llvm/tools/llvm-exegesis/lib/Analysis.cpp

593

Can we call it "outliers" or "unattributed"? noise is a bit vague to me.

[courbet]

llvm/tools/llvm-exegesis/lib/Analysis.cpp

593

"Noise" is the classical dbscan terminology, that has already been used in the Clustering class.

llvm/test/tools/llvm-exegesis/X86/analysis-noise.test

+# RUN: llvm-exegesis -mode=analysis -benchmarks-file=%s -analysis-inconsistencies-output-file=- -analysis-clusters-output-file="" -analysis-numpoints=3 | FileCheck %s
+
+# CHECK: DOCTYPE
+# CHECK: [noise] Cluster (1 points)
+
+---
+mode:            latency
+key:
+  instructions:
+    - 'ADD64rr RAX RAX RDI'
+  config:          ''
+  register_initial_values:
+    - 'RAX=0x0'
+    - 'RDI=0x0'
+cpu_name:        haswell
+llvm_triple:     x86_64-unknown-linux-gnu
+num_repetitions: 10000
+measurements:
+  - { key: latency, value: 1.0049, per_snippet_value: 1.0049 }
+error:           ''
+info:            Repeating a single implicitly serial instruction
+assembled_snippet: 48B8000000000000000048BF00000000000000004801F84801F84801F84801F84801F84801F84801F84801F84801F84801F84801F84801F84801F84801F84801F84801F8C3
+...

llvm/tools/llvm-exegesis/lib/Analysis.h

private:
     InstructionBenchmarkClustering::ClusterId ClusterId;
     std::vector<size_t> PointIds;
     // Measurement stats for the points in the SchedClassCluster.
     SchedClassClusterCentroid Centroid;
   };
 
   void printInstructionRowCsv(size_t PointId, raw_ostream &OS) const;
 
+  void printClusterRawHtml(const InstructionBenchmarkClustering::ClusterId &Id,
+                           StringRef display_name, llvm::raw_ostream &OS) const;
+
+  void printPointHtml(const InstructionBenchmark &Point,
+                      llvm::raw_ostream &OS) const;
+
   void
   printSchedClassClustersHtml(const std::vector<SchedClassCluster> &Clusters,
                               const ResolvedSchedClass &SC,
                               raw_ostream &OS) const;
   void printSchedClassDescHtml(const ResolvedSchedClass &SC,
                                raw_ostream &OS) const;
 
   // A pair of (Sched Class, indices of points that belong to the sched

llvm/tools/llvm-exegesis/lib/Analysis.cpp

for (const MCInst &Instr : Instructions) {
     if (First)
       First = false;
     else
       OS << " &rarr; ";
     writeEscaped<kEscapeHtml>(OS, InstrInfo.getName(Instr.getOpcode()));
   }
 }
 
+void Analysis::printPointHtml(const InstructionBenchmark &Point,
+                              llvm::raw_ostream &OS) const {
+  OS << "<li><span class=\"mono\" title=\"";
+  writeSnippet<EscapeTag, kEscapeHtmlString>(OS, Point.AssembledSnippet, "\n");
+  OS << "\">";
+  switch (Point.Mode) {
+  case InstructionBenchmark::Latency:
+    writeLatencySnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
+    break;
+  case InstructionBenchmark::Uops:
+  case InstructionBenchmark::InverseThroughput:
+    writeUopsSnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
+    break;
+  default:
+    llvm_unreachable("invalid mode");
+  }
+  OS << "</span> <span class=\"mono\">";
+  writeEscaped<kEscapeHtml>(OS, Point.Key.Config);
+  OS << "</span></li>";
+}
+
 void Analysis::printSchedClassClustersHtml(
     const std::vector<SchedClassCluster> &Clusters,
     const ResolvedSchedClass &RSC, raw_ostream &OS) const {
   const auto &Points = Clustering_.getPoints();
   OS << "<table class=\"sched-class-clusters\">";
   OS << "<tr><th>ClusterId</th><th>Opcode/Config</th>";
   assert(!Clusters.empty());
   for (const auto &Measurement :
        Points[Clusters[0].getPointIds()[0]].Measurements) {
     OS << "<th>";
     writeEscaped<kEscapeHtml>(OS, Measurement.Key);
     OS << "</th>";
   }
   OS << "</tr>";
   for (const SchedClassCluster &Cluster : Clusters) {
     OS << "<tr class=\""
        << (Cluster.measurementsMatch(*SubtargetInfo_, RSC, Clustering_,
                                      AnalysisInconsistencyEpsilonSquared_)
                ? "good-cluster"
                : "bad-cluster")
        << "\"><td>";
     writeClusterId<kEscapeHtml>(OS, Cluster.id());
     OS << "</td><td><ul>";
     for (const size_t PointId : Cluster.getPointIds()) {
-      const auto &Point = Points[PointId];
-      OS << "<li><span class=\"mono\" title=\"";
-      writeSnippet<EscapeTag, kEscapeHtmlString>(OS, Point.AssembledSnippet,
-                                                 "\n");
-      OS << "\">";
-      switch (Point.Mode) {
-      case InstructionBenchmark::Latency:
-        writeLatencySnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
-        break;
-      case InstructionBenchmark::Uops:
-      case InstructionBenchmark::InverseThroughput:
-        writeUopsSnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
-        break;
-      default:
-        llvm_unreachable("invalid mode");
-      }
-      OS << "</span> <span class=\"mono\">";
-      writeEscaped<kEscapeHtml>(OS, Point.Key.Config);
-      OS << "</span></li>";
+      printPointHtml(Points[PointId], OS);
     }
     OS << "</ul></td>";
     for (const auto &Stats : Cluster.getCentroid().getStats()) {
       OS << "<td class=\"measurement\">";
       writeMeasurementValue<kEscapeHtml>(OS, Stats.avg());
       OS << "<br><span class=\"minmax\">[";
       writeMeasurementValue<kEscapeHtml>(OS, Stats.min());
       OS << ";";
if (RSC.SCDesc->isValid()) {
     OS << "</ul></td>";
     OS << "</tr>";
   } else {
     OS << "<tr><td>&#10005;</td><td></td><td></td></tr>";
   }
   OS << "</table>";
 }
 
+void Analysis::printClusterRawHtml(
+    const InstructionBenchmarkClustering::ClusterId &Id, StringRef display_name,
+    llvm::raw_ostream &OS) const {
+  const auto &Points = Clustering_.getPoints();
+  const auto &Cluster = Clustering_.getCluster(Id);
+  if (Cluster.PointIndices.empty())
+    return;
+
+  OS << "<div class=\"inconsistency\"><p>" << display_name << " Cluster ("
+     << Cluster.PointIndices.size() << " points)</p>";
+  OS << "<table class=\"sched-class-clusters\">";
+  // Table Header.
+  OS << "<tr><th>ClusterId</th><th>Opcode/Config</th>";
+  for (const auto &Measurement : Points[Cluster.PointIndices[0]].Measurements) {
+    OS << "<th>";
+    writeEscaped<kEscapeHtml>(OS, Measurement.Key);
+    OS << "</th>";
+  }
+  OS << "</tr>";
+
+  // Point data.
+  for (const auto &PointId : Cluster.PointIndices) {
+    OS << "<tr class=\"bad-cluster\"><td>" << display_name << "</td><td><ul>";
+    printPointHtml(Points[PointId], OS);
+    OS << "</ul></td>";
+    for (const auto &Measurement : Points[PointId].Measurements) {
+      OS << "<td class=\"measurement\">";
+      writeMeasurementValue<kEscapeHtml>(OS, Measurement.PerInstructionValue);
+    }
+    OS << "</tr>";
+  }
+  OS << "</table>";
+
+  OS << "</div>";
+
+} // namespace exegesis
+
 static constexpr const char kHtmlHead[] = R"(
 <head>
 <title>llvm-exegesis Analysis Results</title>
 <style>
 body {
   font-family: sans-serif
 }
 span.sched-class-name {
#endif
     OS << "</span> contains instructions whose performance characteristics do"
           " not match that of LLVM:</p>";
     printSchedClassClustersHtml(SchedClassClusters, RSCAndPoints.RSC, OS);
     OS << "<p>llvm SchedModel data:</p>";
     printSchedClassDescHtml(RSCAndPoints.RSC, OS);
     OS << "</div>";
   }
 
+  printClusterRawHtml(InstructionBenchmarkClustering::ClusterId::noise(),
+                      "[noise]", OS);
+
   OS << "</body></html>";
   return Error::success();
 }
 
 } // namespace exegesis
 } // namespace llvm