tools/llvm-exegesis/lib/Analysis.cpp

   1 //===-- Analysis.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "Analysis.h"
  10 #include "BenchmarkResult.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/MC/MCAsmInfo.h"
  13 #include "llvm/Support/FormatVariadic.h"
  14 #include <limits>
  15 #include <unordered_set>
  16 #include <vector>
  17
  18 namespace llvm {
  19 namespace exegesis {
  20
  21 static const char kCsvSep = ',';
  22
  23 namespace {
  24
  25 enum EscapeTag { kEscapeCsv, kEscapeHtml, kEscapeHtmlString };
  26
  27 template <EscapeTag Tag> void writeEscaped(raw_ostream &OS, const StringRef S);
  28
  29 template <> void writeEscaped<kEscapeCsv>(raw_ostream &OS, const StringRef S) {
  30   if (std::find(S.begin(), S.end(), kCsvSep) == S.end()) {
  31     OS << S;
  32   } else {
  33     // Needs escaping.
  34     OS << '"';
  35     for (const char C : S) {
  36       if (C == '"')
  37         OS << "\"\"";
  38       else
  39         OS << C;
  40     }
  41     OS << '"';
  42   }
  43 }
  44
  45 template <> void writeEscaped<kEscapeHtml>(raw_ostream &OS, const StringRef S) {
  46   for (const char C : S) {
  47     if (C == '<')
  48       OS << "&lt;";
  49     else if (C == '>')
  50       OS << "&gt;";
  51     else if (C == '&')
  52       OS << "&amp;";
  53     else
  54       OS << C;
  55   }
  56 }
  57
  58 template <>
  59 void writeEscaped<kEscapeHtmlString>(raw_ostream &OS, const StringRef S) {
  60   for (const char C : S) {
  61     if (C == '"')
  62       OS << "\\\"";
  63     else
  64       OS << C;
  65   }
  66 }
  67
  68 } // namespace
  69
  70 template <EscapeTag Tag>
  71 static void
  72 writeClusterId(raw_ostream &OS,
  73                const InstructionBenchmarkClustering::ClusterId &CID) {
  74   if (CID.isNoise())
  75     writeEscaped<Tag>(OS, "[noise]");
  76   else if (CID.isError())
  77     writeEscaped<Tag>(OS, "[error]");
  78   else
  79     OS << CID.getId();
  80 }
  81
  82 template <EscapeTag Tag>
  83 static void writeMeasurementValue(raw_ostream &OS, const double Value) {
  84   // Given Value, if we wanted to serialize it to a string,
  85   // how many base-10 digits will we need to store, max?
  86   static constexpr auto MaxDigitCount =
  87       std::numeric_limits<decltype(Value)>::max_digits10;
  88   // Also, we will need a decimal separator.
  89   static constexpr auto DecimalSeparatorLen = 1; // '.' e.g.
  90   // So how long of a string will the serialization produce, max?
  91   static constexpr auto SerializationLen = MaxDigitCount + DecimalSeparatorLen;
  92
  93   // WARNING: when changing the format, also adjust the small-size estimate ^.
  94   static constexpr StringLiteral SimpleFloatFormat = StringLiteral("{0:F}");
  95
  96   writeEscaped<Tag>(
  97       OS, formatv(SimpleFloatFormat.data(), Value).sstr<SerializationLen>());
  98 }
  99
 100 template <typename EscapeTag, EscapeTag Tag>
 101 void Analysis::writeSnippet(raw_ostream &OS, ArrayRef<uint8_t> Bytes,
 102                             const char *Separator) const {
 103   SmallVector<std::string, 3> Lines;
 104   // Parse the asm snippet and print it.
 105   while (!Bytes.empty()) {
 106     MCInst MI;
 107     uint64_t MISize = 0;
 108     if (!Disasm_->getInstruction(MI, MISize, Bytes, 0, nulls(), nulls())) {
 109       writeEscaped<Tag>(OS, join(Lines, Separator));
 110       writeEscaped<Tag>(OS, Separator);
 111       writeEscaped<Tag>(OS, "[error decoding asm snippet]");
 112       return;
 113     }
 114     SmallString<128> InstPrinterStr; // FIXME: magic number.
 115     raw_svector_ostream OSS(InstPrinterStr);
 116     InstPrinter_->printInst(&MI, OSS, "", *SubtargetInfo_);
 117     Bytes = Bytes.drop_front(MISize);
 118     Lines.emplace_back(StringRef(InstPrinterStr).trim());
 119   }
 120   writeEscaped<Tag>(OS, join(Lines, Separator));
 121 }
 122
 123 // Prints a row representing an instruction, along with scheduling info and
 124 // point coordinates (measurements).
 125 void Analysis::printInstructionRowCsv(const size_t PointId,
 126                                       raw_ostream &OS) const {
 127   const InstructionBenchmark &Point = Clustering_.getPoints()[PointId];
 128   writeClusterId<kEscapeCsv>(OS, Clustering_.getClusterIdForPoint(PointId));
 129   OS << kCsvSep;
 130   writeSnippet<EscapeTag, kEscapeCsv>(OS, Point.AssembledSnippet, "; ");
 131   OS << kCsvSep;
 132   writeEscaped<kEscapeCsv>(OS, Point.Key.Config);
 133   OS << kCsvSep;
 134   assert(!Point.Key.Instructions.empty());
 135   const MCInst &MCI = Point.keyInstruction();
 136   unsigned SchedClassId;
 137   std::tie(SchedClassId, std::ignore) = ResolvedSchedClass::resolveSchedClassId(
 138       *SubtargetInfo_, *InstrInfo_, MCI);
 139 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 140   const MCSchedClassDesc *const SCDesc =
 141       SubtargetInfo_->getSchedModel().getSchedClassDesc(SchedClassId);
 142   writeEscaped<kEscapeCsv>(OS, SCDesc->Name);
 143 #else
 144   OS << SchedClassId;
 145 #endif
 146   for (const auto &Measurement : Point.Measurements) {
 147     OS << kCsvSep;
 148     writeMeasurementValue<kEscapeCsv>(OS, Measurement.PerInstructionValue);
 149   }
 150   OS << "\n";
 151 }
 152
 153 Analysis::Analysis(const Target &Target, std::unique_ptr<MCInstrInfo> InstrInfo,
 154                    const InstructionBenchmarkClustering &Clustering,
 155                    double AnalysisInconsistencyEpsilon,
 156                    bool AnalysisDisplayUnstableOpcodes)
 157     : Clustering_(Clustering), InstrInfo_(std::move(InstrInfo)),
 158       AnalysisInconsistencyEpsilonSquared_(AnalysisInconsistencyEpsilon *
 159                                            AnalysisInconsistencyEpsilon),
 160       AnalysisDisplayUnstableOpcodes_(AnalysisDisplayUnstableOpcodes) {
 161   if (Clustering.getPoints().empty())
 162     return;
 163
 164   const InstructionBenchmark &FirstPoint = Clustering.getPoints().front();
 165   RegInfo_.reset(Target.createMCRegInfo(FirstPoint.LLVMTriple));
 166   AsmInfo_.reset(Target.createMCAsmInfo(*RegInfo_, FirstPoint.LLVMTriple));
 167   SubtargetInfo_.reset(Target.createMCSubtargetInfo(FirstPoint.LLVMTriple,
 168                                                     FirstPoint.CpuName, ""));
 169   InstPrinter_.reset(Target.createMCInstPrinter(
 170       Triple(FirstPoint.LLVMTriple), 0 /*default variant*/, *AsmInfo_,
 171       *InstrInfo_, *RegInfo_));
 172
 173   Context_ = std::make_unique<MCContext>(AsmInfo_.get(), RegInfo_.get(),
 174                                          &ObjectFileInfo_);
 175   Disasm_.reset(Target.createMCDisassembler(*SubtargetInfo_, *Context_));
 176   assert(Disasm_ && "cannot create MCDisassembler. missing call to "
 177                     "InitializeXXXTargetDisassembler ?");
 178 }
 179
 180 template <>
 181 Error Analysis::run<Analysis::PrintClusters>(raw_ostream &OS) const {
 182   if (Clustering_.getPoints().empty())
 183     return Error::success();
 184
 185   // Write the header.
 186   OS << "cluster_id" << kCsvSep << "opcode_name" << kCsvSep << "config"
 187      << kCsvSep << "sched_class";
 188   for (const auto &Measurement : Clustering_.getPoints().front().Measurements) {
 189     OS << kCsvSep;
 190     writeEscaped<kEscapeCsv>(OS, Measurement.Key);
 191   }
 192   OS << "\n";
 193
 194   // Write the points.
 195   const auto &Clusters = Clustering_.getValidClusters();
 196   for (size_t I = 0, E = Clusters.size(); I < E; ++I) {
 197     for (const size_t PointId : Clusters[I].PointIndices) {
 198       printInstructionRowCsv(PointId, OS);
 199     }
 200     OS << "\n\n";
 201   }
 202   return Error::success();
 203 }
 204
 205 Analysis::ResolvedSchedClassAndPoints::ResolvedSchedClassAndPoints(
 206     ResolvedSchedClass &&RSC)
 207     : RSC(std::move(RSC)) {}
 208
 209 std::vector<Analysis::ResolvedSchedClassAndPoints>
 210 Analysis::makePointsPerSchedClass() const {
 211   std::vector<ResolvedSchedClassAndPoints> Entries;
 212   // Maps SchedClassIds to index in result.
 213   std::unordered_map<unsigned, size_t> SchedClassIdToIndex;
 214   const auto &Points = Clustering_.getPoints();
 215   for (size_t PointId = 0, E = Points.size(); PointId < E; ++PointId) {
 216     const InstructionBenchmark &Point = Points[PointId];
 217     if (!Point.Error.empty())
 218       continue;
 219     assert(!Point.Key.Instructions.empty());
 220     // FIXME: we should be using the tuple of classes for instructions in the
 221     // snippet as key.
 222     const MCInst &MCI = Point.keyInstruction();
 223     unsigned SchedClassId;
 224     bool WasVariant;
 225     std::tie(SchedClassId, WasVariant) =
 226         ResolvedSchedClass::resolveSchedClassId(*SubtargetInfo_, *InstrInfo_,
 227                                                 MCI);
 228     const auto IndexIt = SchedClassIdToIndex.find(SchedClassId);
 229     if (IndexIt == SchedClassIdToIndex.end()) {
 230       // Create a new entry.
 231       SchedClassIdToIndex.emplace(SchedClassId, Entries.size());
 232       ResolvedSchedClassAndPoints Entry(
 233           ResolvedSchedClass(*SubtargetInfo_, SchedClassId, WasVariant));
 234       Entry.PointIds.push_back(PointId);
 235       Entries.push_back(std::move(Entry));
 236     } else {
 237       // Append to the existing entry.
 238       Entries[IndexIt->second].PointIds.push_back(PointId);
 239     }
 240   }
 241   return Entries;
 242 }
 243
 244 // Uops repeat the same opcode over again. Just show this opcode and show the
 245 // whole snippet only on hover.
 246 static void writeUopsSnippetHtml(raw_ostream &OS,
 247                                  const std::vector<MCInst> &Instructions,
 248                                  const MCInstrInfo &InstrInfo) {
 249   if (Instructions.empty())
 250     return;
 251   writeEscaped<kEscapeHtml>(OS, InstrInfo.getName(Instructions[0].getOpcode()));
 252   if (Instructions.size() > 1)
 253     OS << " (x" << Instructions.size() << ")";
 254 }
 255
 256 // Latency tries to find a serial path. Just show the opcode path and show the
 257 // whole snippet only on hover.
 258 static void writeLatencySnippetHtml(raw_ostream &OS,
 259                                     const std::vector<MCInst> &Instructions,
 260                                     const MCInstrInfo &InstrInfo) {
 261   bool First = true;
 262   for (const MCInst &Instr : Instructions) {
 263     if (First)
 264       First = false;
 265     else
 266       OS << " &rarr; ";
 267     writeEscaped<kEscapeHtml>(OS, InstrInfo.getName(Instr.getOpcode()));
 268   }
 269 }
 270
 271 void Analysis::printPointHtml(const InstructionBenchmark &Point,
 272                               llvm::raw_ostream &OS) const {
 273   OS << "<li><span class=\"mono\" title=\"";
 274   writeSnippet<EscapeTag, kEscapeHtmlString>(OS, Point.AssembledSnippet, "\n");
 275   OS << "\">";
 276   switch (Point.Mode) {
 277   case InstructionBenchmark::Latency:
 278     writeLatencySnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
 279     break;
 280   case InstructionBenchmark::Uops:
 281   case InstructionBenchmark::InverseThroughput:
 282     writeUopsSnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
 283     break;
 284   default:
 285     llvm_unreachable("invalid mode");
 286   }
 287   OS << "</span> <span class=\"mono\">";
 288   writeEscaped<kEscapeHtml>(OS, Point.Key.Config);
 289   OS << "</span></li>";
 290 }
 291
 292 void Analysis::printSchedClassClustersHtml(
 293     const std::vector<SchedClassCluster> &Clusters,
 294     const ResolvedSchedClass &RSC, raw_ostream &OS) const {
 295   const auto &Points = Clustering_.getPoints();
 296   OS << "<table class=\"sched-class-clusters\">";
 297   OS << "<tr><th>ClusterId</th><th>Opcode/Config</th>";
 298   assert(!Clusters.empty());
 299   for (const auto &Measurement :
 300        Points[Clusters[0].getPointIds()[0]].Measurements) {
 301     OS << "<th>";
 302     writeEscaped<kEscapeHtml>(OS, Measurement.Key);
 303     OS << "</th>";
 304   }
 305   OS << "</tr>";
 306   for (const SchedClassCluster &Cluster : Clusters) {
 307     OS << "<tr class=\""
 308        << (Cluster.measurementsMatch(*SubtargetInfo_, RSC, Clustering_,
 309                                      AnalysisInconsistencyEpsilonSquared_)
 310                ? "good-cluster"
 311                : "bad-cluster")
 312        << "\"><td>";
 313     writeClusterId<kEscapeHtml>(OS, Cluster.id());
 314     OS << "</td><td><ul>";
 315     for (const size_t PointId : Cluster.getPointIds()) {
 316       printPointHtml(Points[PointId], OS);
 317     }
 318     OS << "</ul></td>";
 319     for (const auto &Stats : Cluster.getCentroid().getStats()) {
 320       OS << "<td class=\"measurement\">";
 321       writeMeasurementValue<kEscapeHtml>(OS, Stats.avg());
 322       OS << "<br><span class=\"minmax\">[";
 323       writeMeasurementValue<kEscapeHtml>(OS, Stats.min());
 324       OS << ";";
 325       writeMeasurementValue<kEscapeHtml>(OS, Stats.max());
 326       OS << "]</span></td>";
 327     }
 328     OS << "</tr>";
 329   }
 330   OS << "</table>";
 331 }
 332
 333 void Analysis::SchedClassCluster::addPoint(
 334     size_t PointId, const InstructionBenchmarkClustering &Clustering) {
 335   PointIds.push_back(PointId);
 336   const auto &Point = Clustering.getPoints()[PointId];
 337   if (ClusterId.isUndef())
 338     ClusterId = Clustering.getClusterIdForPoint(PointId);
 339   assert(ClusterId == Clustering.getClusterIdForPoint(PointId));
 340
 341   Centroid.addPoint(Point.Measurements);
 342 }
 343
 344 bool Analysis::SchedClassCluster::measurementsMatch(
 345     const MCSubtargetInfo &STI, const ResolvedSchedClass &RSC,
 346     const InstructionBenchmarkClustering &Clustering,
 347     const double AnalysisInconsistencyEpsilonSquared_) const {
 348   assert(!Clustering.getPoints().empty());
 349   const InstructionBenchmark::ModeE Mode = Clustering.getPoints()[0].Mode;
 350
 351   if (!Centroid.validate(Mode))
 352     return false;
 353
 354   const std::vector<BenchmarkMeasure> ClusterCenterPoint =
 355       Centroid.getAsPoint();
 356
 357   const std::vector<BenchmarkMeasure> SchedClassPoint =
 358       RSC.getAsPoint(Mode, STI, Centroid.getStats());
 359   if (SchedClassPoint.empty())
 360     return false; // In Uops mode validate() may not be enough.
 361
 362   assert(ClusterCenterPoint.size() == SchedClassPoint.size() &&
 363          "Expected measured/sched data dimensions to match.");
 364
 365   return Clustering.isNeighbour(ClusterCenterPoint, SchedClassPoint,
 366                                 AnalysisInconsistencyEpsilonSquared_);
 367 }
 368
 369 void Analysis::printSchedClassDescHtml(const ResolvedSchedClass &RSC,
 370                                        raw_ostream &OS) const {
 371   OS << "<table class=\"sched-class-desc\">";
 372   OS << "<tr><th>Valid</th><th>Variant</th><th>NumMicroOps</th><th>Latency</"
 373         "th><th>RThroughput</th><th>WriteProcRes</th><th title=\"This is the "
 374         "idealized unit resource (port) pressure assuming ideal "
 375         "distribution\">Idealized Resource Pressure</th></tr>";
 376   if (RSC.SCDesc->isValid()) {
 377     const auto &SM = SubtargetInfo_->getSchedModel();
 378     OS << "<tr><td>&#10004;</td>";
 379     OS << "<td>" << (RSC.WasVariant ? "&#10004;" : "&#10005;") << "</td>";
 380     OS << "<td>" << RSC.SCDesc->NumMicroOps << "</td>";
 381     // Latencies.
 382     OS << "<td><ul>";
 383     for (int I = 0, E = RSC.SCDesc->NumWriteLatencyEntries; I < E; ++I) {
 384       const auto *const Entry =
 385           SubtargetInfo_->getWriteLatencyEntry(RSC.SCDesc, I);
 386       OS << "<li>" << Entry->Cycles;
 387       if (RSC.SCDesc->NumWriteLatencyEntries > 1) {
 388         // Dismabiguate if more than 1 latency.
 389         OS << " (WriteResourceID " << Entry->WriteResourceID << ")";
 390       }
 391       OS << "</li>";
 392     }
 393     OS << "</ul></td>";
 394     // inverse throughput.
 395     OS << "<td>";
 396     writeMeasurementValue<kEscapeHtml>(
 397         OS,
 398         MCSchedModel::getReciprocalThroughput(*SubtargetInfo_, *RSC.SCDesc));
 399     OS << "</td>";
 400     // WriteProcRes.
 401     OS << "<td><ul>";
 402     for (const auto &WPR : RSC.NonRedundantWriteProcRes) {
 403       OS << "<li><span class=\"mono\">";
 404       writeEscaped<kEscapeHtml>(OS,
 405                                 SM.getProcResource(WPR.ProcResourceIdx)->Name);
 406       OS << "</span>: " << WPR.Cycles << "</li>";
 407     }
 408     OS << "</ul></td>";
 409     // Idealized port pressure.
 410     OS << "<td><ul>";
 411     for (const auto &Pressure : RSC.IdealizedProcResPressure) {
 412       OS << "<li><span class=\"mono\">";
 413       writeEscaped<kEscapeHtml>(OS, SubtargetInfo_->getSchedModel()
 414                                         .getProcResource(Pressure.first)
 415                                         ->Name);
 416       OS << "</span>: ";
 417       writeMeasurementValue<kEscapeHtml>(OS, Pressure.second);
 418       OS << "</li>";
 419     }
 420     OS << "</ul></td>";
 421     OS << "</tr>";
 422   } else {
 423     OS << "<tr><td>&#10005;</td><td></td><td></td></tr>";
 424   }
 425   OS << "</table>";
 426 }
 427
 428 void Analysis::printClusterRawHtml(
 429     const InstructionBenchmarkClustering::ClusterId &Id, StringRef display_name,
 430     llvm::raw_ostream &OS) const {
 431   const auto &Points = Clustering_.getPoints();
 432   const auto &Cluster = Clustering_.getCluster(Id);
 433   if (Cluster.PointIndices.empty())
 434     return;
 435
 436   OS << "<div class=\"inconsistency\"><p>" << display_name << " Cluster ("
 437      << Cluster.PointIndices.size() << " points)</p>";
 438   OS << "<table class=\"sched-class-clusters\">";
 439   // Table Header.
 440   OS << "<tr><th>ClusterId</th><th>Opcode/Config</th>";
 441   for (const auto &Measurement : Points[Cluster.PointIndices[0]].Measurements) {
 442     OS << "<th>";
 443     writeEscaped<kEscapeHtml>(OS, Measurement.Key);
 444     OS << "</th>";
 445   }
 446   OS << "</tr>";
 447
 448   // Point data.
 449   for (const auto &PointId : Cluster.PointIndices) {
 450     OS << "<tr class=\"bad-cluster\"><td>" << display_name << "</td><td><ul>";
 451     printPointHtml(Points[PointId], OS);
 452     OS << "</ul></td>";
 453     for (const auto &Measurement : Points[PointId].Measurements) {
 454       OS << "<td class=\"measurement\">";
 455       writeMeasurementValue<kEscapeHtml>(OS, Measurement.PerInstructionValue);
 456     }
 457     OS << "</tr>";
 458   }
 459   OS << "</table>";
 460
 461   OS << "</div>";
 462
 463 } // namespace exegesis
 464
 465 static constexpr const char kHtmlHead[] = R"(
 466 <head>
 467 <title>llvm-exegesis Analysis Results</title>
 468 <style>
 469 body {
 470   font-family: sans-serif
 471 }
 472 span.sched-class-name {
 473   font-weight: bold;
 474   font-family: monospace;
 475 }
 476 span.opcode {
 477   font-family: monospace;
 478 }
 479 span.config {
 480   font-family: monospace;
 481 }
 482 div.inconsistency {
 483   margin-top: 50px;
 484 }
 485 table {
 486   margin-left: 50px;
 487   border-collapse: collapse;
 488 }
 489 table, table tr,td,th {
 490   border: 1px solid #444;
 491 }
 492 table ul {
 493   padding-left: 0px;
 494   margin: 0px;
 495   list-style-type: none;
 496 }
 497 table.sched-class-clusters td {
 498   padding-left: 10px;
 499   padding-right: 10px;
 500   padding-top: 10px;
 501   padding-bottom: 10px;
 502 }
 503 table.sched-class-desc td {
 504   padding-left: 10px;
 505   padding-right: 10px;
 506   padding-top: 2px;
 507   padding-bottom: 2px;
 508 }
 509 span.mono {
 510   font-family: monospace;
 511 }
 512 td.measurement {
 513   text-align: center;
 514 }
 515 tr.good-cluster td.measurement {
 516   color: #292
 517 }
 518 tr.bad-cluster td.measurement {
 519   color: #922
 520 }
 521 tr.good-cluster td.measurement span.minmax {
 522   color: #888;
 523 }
 524 tr.bad-cluster td.measurement span.minmax {
 525   color: #888;
 526 }
 527 </style>
 528 </head>
 529 )";
 530
 531 template <>
 532 Error Analysis::run<Analysis::PrintSchedClassInconsistencies>(
 533     raw_ostream &OS) const {
 534   const auto &FirstPoint = Clustering_.getPoints()[0];
 535   // Print the header.
 536   OS << "<!DOCTYPE html><html>" << kHtmlHead << "<body>";
 537   OS << "<h1><span class=\"mono\">llvm-exegesis</span> Analysis Results</h1>";
 538   OS << "<h3>Triple: <span class=\"mono\">";
 539   writeEscaped<kEscapeHtml>(OS, FirstPoint.LLVMTriple);
 540   OS << "</span></h3><h3>Cpu: <span class=\"mono\">";
 541   writeEscaped<kEscapeHtml>(OS, FirstPoint.CpuName);
 542   OS << "</span></h3>";
 543
 544   for (const auto &RSCAndPoints : makePointsPerSchedClass()) {
 545     if (!RSCAndPoints.RSC.SCDesc)
 546       continue;
 547     // Bucket sched class points into sched class clusters.
 548     std::vector<SchedClassCluster> SchedClassClusters;
 549     for (const size_t PointId : RSCAndPoints.PointIds) {
 550       const auto &ClusterId = Clustering_.getClusterIdForPoint(PointId);
 551       if (!ClusterId.isValid())
 552         continue; // Ignore noise and errors. FIXME: take noise into account ?
 553       if (ClusterId.isUnstable() ^ AnalysisDisplayUnstableOpcodes_)
 554         continue; // Either display stable or unstable clusters only.
 555       auto SchedClassClusterIt =
 556           std::find_if(SchedClassClusters.begin(), SchedClassClusters.end(),
 557                        [ClusterId](const SchedClassCluster &C) {
 558                          return C.id() == ClusterId;
 559                        });
 560       if (SchedClassClusterIt == SchedClassClusters.end()) {
 561         SchedClassClusters.emplace_back();
 562         SchedClassClusterIt = std::prev(SchedClassClusters.end());
 563       }
 564       SchedClassClusterIt->addPoint(PointId, Clustering_);
 565     }
 566
 567     // Print any scheduling class that has at least one cluster that does not
 568     // match the checked-in data.
 569     if (all_of(SchedClassClusters, [this,
 570                                     &RSCAndPoints](const SchedClassCluster &C) {
 571           return C.measurementsMatch(*SubtargetInfo_, RSCAndPoints.RSC,
 572                                      Clustering_,
 573                                      AnalysisInconsistencyEpsilonSquared_);
 574         }))
 575       continue; // Nothing weird.
 576
 577     OS << "<div class=\"inconsistency\"><p>Sched Class <span "
 578           "class=\"sched-class-name\">";
 579 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 580     writeEscaped<kEscapeHtml>(OS, RSCAndPoints.RSC.SCDesc->Name);
 581 #else
 582     OS << RSCAndPoints.RSC.SchedClassId;
 583 #endif
 584     OS << "</span> contains instructions whose performance characteristics do"
 585           " not match that of LLVM:</p>";
 586     printSchedClassClustersHtml(SchedClassClusters, RSCAndPoints.RSC, OS);
 587     OS << "<p>llvm SchedModel data:</p>";
 588     printSchedClassDescHtml(RSCAndPoints.RSC, OS);
 589     OS << "</div>";
 590   }
 591
 592   printClusterRawHtml(InstructionBenchmarkClustering::ClusterId::noise(),
 593                       "[noise]", OS);
 594
 595   OS << "</body></html>";
 596   return Error::success();
 597 }
 598
 599 } // namespace exegesis
 600 } // namespace llvm