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