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