[llvm-exegesis] Throughput support in analysis mode

[lebedev.ri]

Summary

D57000 / PR37698 added support for measuring of the inverse throughput.
But the support for the analysis was not added.
This attempts to fix that. (analysis done o bdver2 / piledriver)

First, small-scale experiment:

$ ./bin/llvm-exegesis -num-repetitions=10000 -mode=inverse_throughput -opcode-name=BSF64rr
Check generated assembly with: /usr/bin/objdump -d /tmp/snippet-d0acdd.o
---
mode:            inverse_throughput
key:             
  instructions:    
    - 'BSF64rr RAX RDX'
  config:          ''
  register_initial_values: 
    - 'RDX=0x0'
cpu_name:        bdver2
llvm_triple:     x86_64-unknown-linux-gnu
num_repetitions: 10000
measurements:    
  - { key: inverse_throughput, value: 3.0278, per_snippet_value: 3.0278 }
error:           ''
info:            instruction has no tied variables picking Uses different from defs
assembled_snippet: 48BA0000000000000000480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2480FBCC2C3
...

If we plug bsfq %r12, %r10 into llvm-mca:
https://godbolt.org/z/ZtOyhJ

Dispatch Width:    4
uOps Per Cycle:    3.00
IPC:               0.50
Block RThroughput: 2.0

So RThroughput mismatch exists.

Now, let's upscale and analyse:

benchmarks-inverse_throughput.yaml71 MBDownload

$ ./bin/llvm-exegesis -mode=analysis -analysis-epsilon=1.0 -benchmarks-file=/tmp/benchmarks-inverse_throughput.yaml -analysis-inconsistencies-output-file=/tmp/clusters.html:

clusters.html2 MBDownload

And if we now look at https://www.agner.org/optimize/instruction_tables.pdf,
Reciprocal throughput for BSF r,r is listed as 3.
Yay?

[courbet]

Thanks for working on this Roman !

Yay?

Indeed :)

I've had a look a the analysis file, there a bunch of other interesting ones, e.g. BT, BTC, CRC32, DPPD

We seem to be doing a bad job on X87, but that does not surprise me too much :(

[lebedev.ri]

In D57647#1382720, @courbet wrote:

Thanks for working on this Roman !

Yay?

Indeed :)

Thank you for the review :)

I've had a look a the analysis file, there a bunch of other interesting ones, e.g. BT, BTC, CRC32, DPPD

We seem to be doing a bad job on X87, but that does not surprise me too much :(

tools/llvm-exegesis/lib/Analysis.cpp

515 ↗

(On Diff #184939)

@courbet one point of note here. Is min() the correct pick?
It does not seem to matter though, and is what is done in https://reviews.llvm.org/D57000#change-FpxQcgWblhyw

case InstructionBenchmark::InverseThroughput:
  Result = {BenchmarkMeasure::Create("inverse_throughput", MinValue)};

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

for (const size_t PointId : Cluster.getPointIds()) {
       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>";
for (int I = 0, E = Representative.size(); I < E; ++I) {
       } else {
         llvm::errs() << "expected `key` to be either a ProcResIdx or a ProcRes "
                         "name, got "
                      << Key << "\n";
         return false;
       }
       ClusterCenterPoint[I].PerInstructionValue = Representative[I].avg();
     }
+  } else if (Mode == InstructionBenchmark::InverseThroughput) {
+    for (int I = 0, E = Representative.size(); I < E; ++I) {
+      SchedClassPoint[I].PerInstructionValue =
+          MCSchedModel::getReciprocalThroughput(STI, *RSC.SCDesc);
+      ClusterCenterPoint[I].PerInstructionValue = Representative[I].min();
+    }
   } else {
-    llvm::errs() << "unimplemented measurement matching for mode " << Mode
-                 << "\n";
+    llvm_unreachable("unimplemented measurement matching mode");
     return false;
   }
   return Clustering.isNeighbour(ClusterCenterPoint, SchedClassPoint);
 }
 
 void Analysis::printSchedClassDescHtml(const ResolvedSchedClass &RSC,
                                        llvm::raw_ostream &OS) const {
   OS << "<table class=\"sched-class-desc\">";
   OS << "<tr><th>Valid</th><th>Variant</th><th>NumMicroOps</th><th>Latency</"
-        "th><th>WriteProcRes</th><th title=\"This is the idealized unit "
-        "resource (port) pressure assuming ideal distribution\">Idealized "
-        "Resource Pressure</th></tr>";
+        "th><th>RThroughput</th><th>WriteProcRes</th><th title=\"This is the "
+        "idealized unit resource (port) pressure assuming ideal "
+        "distribution\">Idealized Resource Pressure</th></tr>";
   if (RSC.SCDesc->isValid()) {
     const auto &SM = SubtargetInfo_->getSchedModel();
     OS << "<tr><td>&#10004;</td>";
     OS << "<td>" << (RSC.WasVariant ? "&#10004;" : "&#10005;") << "</td>";
     OS << "<td>" << RSC.SCDesc->NumMicroOps << "</td>";
     // Latencies.
     OS << "<td><ul>";
     for (int I = 0, E = RSC.SCDesc->NumWriteLatencyEntries; I < E; ++I) {
       const auto *const Entry =
           SubtargetInfo_->getWriteLatencyEntry(RSC.SCDesc, I);
       OS << "<li>" << Entry->Cycles;
       if (RSC.SCDesc->NumWriteLatencyEntries > 1) {
         // Dismabiguate if more than 1 latency.
         OS << " (WriteResourceID " << Entry->WriteResourceID << ")";
       }
       OS << "</li>";
     }
     OS << "</ul></td>";
+    // inverse throughput.
+    OS << "<td>";
+    writeMeasurementValue<kEscapeHtml>(
+        OS,
+        MCSchedModel::getReciprocalThroughput(*SubtargetInfo_, *RSC.SCDesc));
+    OS << "</td>";
     // WriteProcRes.
     OS << "<td><ul>";
     for (const auto &WPR : RSC.NonRedundantWriteProcRes) {
       OS << "<li><span class=\"mono\">";
       writeEscaped<kEscapeHtml>(OS,
                                 SM.getProcResource(WPR.ProcResourceIdx)->Name);
       OS << "</span>: " << WPR.Cycles << "</li>";
     }