[NFC][llvm-exegesis] Also promote getSchedClassPoint() into ResolvedSchedClass.

[lebedev.ri]

Summary

It doesn't need anything from Analysis::SchedClassCluster class,
and takes ResolvedSchedClass as param, so this seems rather fitting.

tools/llvm-exegesis/lib/Analysis.h

public:
     const std::vector<size_t> &getPointIds() const { return PointIds; }
 
     void addPoint(size_t PointId,
                   const InstructionBenchmarkClustering &Clustering);
 
     // Return the cluster centroid.
     const SchedClassClusterCentroid &getCentroid() const { return Centroid; }
 
-    std::vector<BenchmarkMeasure>
-    getSchedClassPoint(InstructionBenchmark::ModeE Mode,
-                       const llvm::MCSubtargetInfo &STI,
-                       const ResolvedSchedClass &SC,
-                       ArrayRef<PerInstructionStats> Representative) const;
-
     // Returns true if the cluster representative measurements match that of SC.
     bool
     measurementsMatch(const llvm::MCSubtargetInfo &STI,
                       const ResolvedSchedClass &SC,
                       const InstructionBenchmarkClustering &Clustering,
                       const double AnalysisInconsistencyEpsilonSquared_) const;
 
   private:

tools/llvm-exegesis/lib/Analysis.cpp

void Analysis::SchedClassCluster::addPoint(
   const auto &Point = Clustering.getPoints()[PointId];
   if (ClusterId.isUndef())
     ClusterId = Clustering.getClusterIdForPoint(PointId);
   assert(ClusterId == Clustering.getClusterIdForPoint(PointId));
 
   Centroid.addPoint(Point.Measurements);
 }
 
-// Returns a ProxResIdx by id or name.
-static unsigned findProcResIdx(const llvm::MCSubtargetInfo &STI,
-                               const llvm::StringRef NameOrId) {
-  // Interpret the key as an ProcResIdx.
-  unsigned ProcResIdx = 0;
-  if (llvm::to_integer(NameOrId, ProcResIdx, 10))
-    return ProcResIdx;
-  // Interpret the key as a ProcRes name.
-  const auto &SchedModel = STI.getSchedModel();
-  for (int I = 0, E = SchedModel.getNumProcResourceKinds(); I < E; ++I) {
-    if (NameOrId == SchedModel.getProcResource(I)->Name)
-      return I;
-  }
-  return 0;
-}
-
-std::vector<BenchmarkMeasure> Analysis::SchedClassCluster::getSchedClassPoint(
-    InstructionBenchmark::ModeE Mode, const llvm::MCSubtargetInfo &STI,
-    const ResolvedSchedClass &RSC,
-    ArrayRef<PerInstructionStats> Representative) const {
-  const size_t NumMeasurements = Representative.size();
-
-  std::vector<BenchmarkMeasure> SchedClassPoint(NumMeasurements);
-
-  if (Mode == InstructionBenchmark::Latency) {
-    assert(NumMeasurements == 1 && "Latency is a single measure.");
-    BenchmarkMeasure &LatencyMeasure = SchedClassPoint[0];
-
-    // Find the latency.
-    LatencyMeasure.PerInstructionValue = 0.0;
-
-    for (unsigned I = 0; I < RSC.SCDesc->NumWriteLatencyEntries; ++I) {
-      const llvm::MCWriteLatencyEntry *const WLE =
-          STI.getWriteLatencyEntry(RSC.SCDesc, I);
-      LatencyMeasure.PerInstructionValue =
-          std::max<double>(LatencyMeasure.PerInstructionValue, WLE->Cycles);
-    }
-  } else if (Mode == InstructionBenchmark::Uops) {
-    for (const auto &I : llvm::zip(SchedClassPoint, Representative)) {
-      BenchmarkMeasure &Measure = std::get<0>(I);
-      const PerInstructionStats &Stats = std::get<1>(I);
-
-      StringRef Key = Stats.key();
-      uint16_t ProcResIdx = findProcResIdx(STI, Key);
-      if (ProcResIdx > 0) {
-        // Find the pressure on ProcResIdx `Key`.
-        const auto ProcResPressureIt =
-            std::find_if(RSC.IdealizedProcResPressure.begin(),
-                         RSC.IdealizedProcResPressure.end(),
-                         [ProcResIdx](const std::pair<uint16_t, float> &WPR) {
-                           return WPR.first == ProcResIdx;
-                         });
-        Measure.PerInstructionValue =
-            ProcResPressureIt == RSC.IdealizedProcResPressure.end()
-                ? 0.0
-                : ProcResPressureIt->second;
-      } else if (Key == "NumMicroOps") {
-        Measure.PerInstructionValue = RSC.SCDesc->NumMicroOps;
-      } else {
-        llvm::errs() << "expected `key` to be either a ProcResIdx or a ProcRes "
-                        "name, got "
-                     << Key << "\n";
-        return {};
-      }
-    }
-  } else if (Mode == InstructionBenchmark::InverseThroughput) {
-    assert(NumMeasurements == 1 && "Inverse Throughput is a single measure.");
-    BenchmarkMeasure &RThroughputMeasure = SchedClassPoint[0];
-
-    RThroughputMeasure.PerInstructionValue =
-        MCSchedModel::getReciprocalThroughput(STI, *RSC.SCDesc);
-  } else {
-    llvm_unreachable("unimplemented measurement matching mode");
-  }
-
-  return SchedClassPoint;
-}
-
 bool Analysis::SchedClassCluster::measurementsMatch(
     const llvm::MCSubtargetInfo &STI, const ResolvedSchedClass &RSC,
     const InstructionBenchmarkClustering &Clustering,
     const double AnalysisInconsistencyEpsilonSquared_) const {
   assert(!Clustering.getPoints().empty());
   const InstructionBenchmark::ModeE Mode = Clustering.getPoints()[0].Mode;
 
   if (!Centroid.validate(Mode))
     return false;
 
   const std::vector<BenchmarkMeasure> ClusterCenterPoint =
       Centroid.getAsPoint();
 
   const std::vector<BenchmarkMeasure> SchedClassPoint =
-      getSchedClassPoint(Mode, STI, RSC, Centroid.getStats());
+      RSC.getAsPoint(Mode, STI, Centroid.getStats());
   if (SchedClassPoint.empty())
     return false; // In Uops mode validate() may not be enough.
 
   assert(ClusterCenterPoint.size() == SchedClassPoint.size() &&
          "Expected measured/sched data dimensions to match.");
 
   return Clustering.isNeighbour(ClusterCenterPoint, SchedClassPoint,
                                 AnalysisInconsistencyEpsilonSquared_);

tools/llvm-exegesis/lib/SchedClassResolution.h

 //===-- SchedClassResolution.h ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// Analysis output for benchmark results.
+/// Resolution of MCInst sched class into expanded form for further analysis.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_SCHEDCLASSRESOLUTION_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_SCHEDCLASSRESOLUTION_H
 
+#include "BenchmarkResult.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/TargetRegistry.h"
struct ResolvedSchedClass {
   ResolvedSchedClass(const llvm::MCSubtargetInfo &STI,
                      unsigned ResolvedSchedClassId, bool WasVariant);
 
   static std::pair<unsigned /*SchedClassId*/, bool /*WasVariant*/>
   resolveSchedClassId(const llvm::MCSubtargetInfo &SubtargetInfo,
                       const llvm::MCInstrInfo &InstrInfo,
                       const llvm::MCInst &MCI);
 
+  std::vector<BenchmarkMeasure>
+  getAsPoint(InstructionBenchmark::ModeE Mode, const llvm::MCSubtargetInfo &STI,
+             ArrayRef<PerInstructionStats> Representative) const;
+
   const unsigned SchedClassId;
   const llvm::MCSchedClassDesc *const SCDesc;
   const bool WasVariant; // Whether the original class was variant.
   const llvm::SmallVector<llvm::MCWriteProcResEntry, 8>
       NonRedundantWriteProcRes;
   const std::vector<std::pair<uint16_t, float>> IdealizedProcResPressure;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_SCHEDCLASSRESOLUTION_H

tools/llvm-exegesis/lib/SchedClassResolution.cpp

ResolvedSchedClass::resolveSchedClassId(
   unsigned SchedClassId = InstrInfo.get(MCI.getOpcode()).getSchedClass();
   const bool WasVariant = SchedClassId && SubtargetInfo.getSchedModel()
                                               .getSchedClassDesc(SchedClassId)
                                               ->isVariant();
   SchedClassId = ResolveVariantSchedClassId(SubtargetInfo, SchedClassId, MCI);
   return std::make_pair(SchedClassId, WasVariant);
 }
 
+// Returns a ProxResIdx by id or name.
+static unsigned findProcResIdx(const llvm::MCSubtargetInfo &STI,
+                               const llvm::StringRef NameOrId) {
+  // Interpret the key as an ProcResIdx.
+  unsigned ProcResIdx = 0;
+  if (llvm::to_integer(NameOrId, ProcResIdx, 10))
+    return ProcResIdx;
+  // Interpret the key as a ProcRes name.
+  const auto &SchedModel = STI.getSchedModel();
+  for (int I = 0, E = SchedModel.getNumProcResourceKinds(); I < E; ++I) {
+    if (NameOrId == SchedModel.getProcResource(I)->Name)
+      return I;
+  }
+  return 0;
+}
+
+std::vector<BenchmarkMeasure> ResolvedSchedClass::getAsPoint(
+    InstructionBenchmark::ModeE Mode, const llvm::MCSubtargetInfo &STI,
+    ArrayRef<PerInstructionStats> Representative) const {
+  const size_t NumMeasurements = Representative.size();
+
+  std::vector<BenchmarkMeasure> SchedClassPoint(NumMeasurements);
+
+  if (Mode == InstructionBenchmark::Latency) {
+    assert(NumMeasurements == 1 && "Latency is a single measure.");
+    BenchmarkMeasure &LatencyMeasure = SchedClassPoint[0];
+
+    // Find the latency.
+    LatencyMeasure.PerInstructionValue = 0.0;
+
+    for (unsigned I = 0; I < SCDesc->NumWriteLatencyEntries; ++I) {
+      const llvm::MCWriteLatencyEntry *const WLE =
+          STI.getWriteLatencyEntry(SCDesc, I);
+      LatencyMeasure.PerInstructionValue =
+          std::max<double>(LatencyMeasure.PerInstructionValue, WLE->Cycles);
+    }
+  } else if (Mode == InstructionBenchmark::Uops) {
+    for (const auto &I : llvm::zip(SchedClassPoint, Representative)) {
+      BenchmarkMeasure &Measure = std::get<0>(I);
+      const PerInstructionStats &Stats = std::get<1>(I);
+
+      StringRef Key = Stats.key();
+      uint16_t ProcResIdx = findProcResIdx(STI, Key);
+      if (ProcResIdx > 0) {
+        // Find the pressure on ProcResIdx `Key`.
+        const auto ProcResPressureIt = std::find_if(
+            IdealizedProcResPressure.begin(), IdealizedProcResPressure.end(),
+            [ProcResIdx](const std::pair<uint16_t, float> &WPR) {
+              return WPR.first == ProcResIdx;
+            });
+        Measure.PerInstructionValue =
+            ProcResPressureIt == IdealizedProcResPressure.end()
+                ? 0.0
+                : ProcResPressureIt->second;
+      } else if (Key == "NumMicroOps") {
+        Measure.PerInstructionValue = SCDesc->NumMicroOps;
+      } else {
+        llvm::errs() << "expected `key` to be either a ProcResIdx or a ProcRes "
+                        "name, got "
+                     << Key << "\n";
+        return {};
+      }
+    }
+  } else if (Mode == InstructionBenchmark::InverseThroughput) {
+    assert(NumMeasurements == 1 && "Inverse Throughput is a single measure.");
+    BenchmarkMeasure &RThroughputMeasure = SchedClassPoint[0];
+
+    RThroughputMeasure.PerInstructionValue =
+        MCSchedModel::getReciprocalThroughput(STI, *SCDesc);
+  } else {
+    llvm_unreachable("unimplemented measurement matching mode");
+  }
+
+  return SchedClassPoint;
+}
+
 } // namespace exegesis
 } // namespace llvm