[llvm-exegesis] Write out inconsistencies to a file.

[gchatelet]

tools/llvm-exegesis/llvm-exegesis.cpp

178 ↗

(On Diff #147300)

Since there's no performance issue here, I'd rather separate the report generation from saving it:

std::string ClusterReport;
if (auto Err = Analyzer.printClusters(llvm::raw_string_ostream(ClusterReport))) {
  PrintAnalysis("analysis clusters", AnalysisClustersFile, ClusterReport );
}

std::string InconsistenciesReport;
if (auto Err = Analyzer.printClusters(llvm::raw_string_ostream(InconsistenciesReport))) {
  PrintAnalysis("sched class consistency analysis", AnalysisInconsistenciesFile, InconsistenciesReport );
}

[courbet]

Slightly better approach for analysis pass selection.

[courbet]

remove accidentally added file

[courbet]

clang-format

[courbet]

cosmetics

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

 
 // A helper class to analyze benchmark results for a target.
 class Analysis {
 public:
   Analysis(const llvm::Target &Target,
            const InstructionBenchmarkClustering &Clustering);
 
   // Prints a csv of instructions for each cluster.
-  llvm::Error printClusters(llvm::raw_ostream &OS) const;
-
+  struct PrintClusters {};
   // Find potential errors in the scheduling information given measurements.
-  llvm::Error printSchedClassInconsistencies(llvm::raw_ostream &OS) const;
+  struct PrintSchedClassInconsistencies {};
+
+  template <typename Pass> llvm::Error run(llvm::raw_ostream &OS) const;
 
 private:
   void printInstructionRow(bool PrintSchedClass, size_t PointId,
                            llvm::raw_ostream &OS) const;
 
   // Builds a map of Sched Class -> indices of points that belong to the sched
   // class.
   std::unordered_map<unsigned, std::vector<size_t>>

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

Analysis::Analysis(const llvm::Target &Target,
   SubtargetInfo_.reset(Target.createMCSubtargetInfo(FirstPoint.LLVMTriple,
                                                     FirstPoint.CpuName, ""));
 
   // Build an index of mnemonic->opcode.
   for (int I = 0, E = InstrInfo_->getNumOpcodes(); I < E; ++I)
     MnemonicToOpcode_.emplace(InstrInfo_->getName(I), I);
 }
 
-llvm::Error Analysis::printClusters(llvm::raw_ostream &OS) const {
+template <>
+llvm::Error
+Analysis::run<Analysis::PrintClusters>(llvm::raw_ostream &OS) const {
   if (Clustering_.getPoints().empty())
     return llvm::Error::success();
 
   // Write the header.
   OS << "cluster_id" << kCsvSep << "opcode_name" << kCsvSep << "config"
      << kCsvSep << "sched_class";
   for (const auto &Measurement : Clustering_.getPoints().front().Measurements) {
     OS << kCsvSep;
if (OpcodeIt == MnemonicToOpcode_.end())
       continue;
     const unsigned SchedClassId =
         InstrInfo_->get(OpcodeIt->second).getSchedClass();
     PointsPerSchedClass[SchedClassId].push_back(PointId);
   }
   return PointsPerSchedClass;
 }
 
-llvm::Error
-Analysis::printSchedClassInconsistencies(llvm::raw_ostream &OS) const {
+template <>
+llvm::Error Analysis::run<Analysis::PrintSchedClassInconsistencies>(
+    llvm::raw_ostream &OS) const {
   // All the points in a scheduling class should be in the same cluster.
   // Print any scheduling class for which this is not the case.
   for (const auto &SchedClassAndPoints : makePointsPerSchedClass()) {
     std::unordered_set<size_t> ClustersForSchedClass;
     for (const size_t PointId : SchedClassAndPoints.second) {
       const auto &ClusterId = Clustering_.getClusterIdForPoint(PointId);
       if (!ClusterId.isValid())
         continue; // Ignore noise and errors.
OS << " contains instructions with distinct performance "
        << ClustersForSchedClass.size() << " clusters:\n";
     for (const size_t PointId : SchedClassAndPoints.second) {
       printInstructionRow(/*PrintSchedClass*/ false, PointId, OS);
     }
   }
   return llvm::Error::success();
 }
 
+template llvm::Error
+Analysis::run<Analysis::PrintClusters>(llvm::raw_ostream &OS) const;
+template llvm::Error Analysis::run<Analysis::PrintSchedClassInconsistencies>(
+    llvm::raw_ostream &OS) const;
+
 } // namespace exegesis

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

static llvm::cl::opt<unsigned> AnalysisNumPoints(
     llvm::cl::desc("minimum number of points in an analysis cluster"),
     llvm::cl::init(3));
 
 static llvm::cl::opt<float>
     AnalysisEpsilon("analysis-epsilon",
                     llvm::cl::desc("dbscan epsilon for analysis clustering"),
                     llvm::cl::init(0.1));
 
-static llvm::cl::opt<std::string> AnalysisClustersFile("analysis-clusters-file",
-                                                       llvm::cl::desc(""),
-                                                       llvm::cl::init("-"));
+static llvm::cl::opt<std::string>
+    AnalysisClustersOutputFile("analysis-clusters-output-file",
+                               llvm::cl::desc(""), llvm::cl::init("-"));
+static llvm::cl::opt<std::string>
+    AnalysisInconsistenciesOutputFile("analysis-inconsistencies-output-file",
+                                      llvm::cl::desc(""), llvm::cl::init("-"));
 
 namespace exegesis {
 
 static unsigned GetOpcodeOrDie(const llvm::MCInstrInfo &MCInstrInfo) {
   if (OpcodeName.empty() && (OpcodeIndex == 0))
     llvm::report_fatal_error(
         "please provide one and only one of 'opcode-index' or 'opcode-name'");
   if (OpcodeIndex > 0)
void benchmarkMain() {
   if (NumRepetitions == 0)
     llvm::report_fatal_error("--num-repetitions must be greater than zero");
 
   Runner->run(GetOpcodeOrDie(State.getInstrInfo()), Filter, NumRepetitions)
       .writeYamlOrDie(BenchmarkFile);
   exegesis::pfm::pfmTerminate();
 }
 
-void analysisMain() {
+// Prints the results of running analysis pass `Pass` to file `OutputFilename`
+// if OutputFilename is non-empty.
+template <typename Pass>
+static void maybeRunAnalysis(const Analysis &Analyzer, const std::string &Name,
+                      const std::string &OutputFilename) {
+  if (OutputFilename.empty())
+    return;
+  if (OutputFilename != "-") {
+    llvm::errs() << "Printing " << Name << " results to file '"
+                 << OutputFilename << "'\n";
+  }
+  std::error_code ErrorCode;
+  llvm::raw_fd_ostream ClustersOS(OutputFilename, ErrorCode,
+                                  llvm::sys::fs::F_RW);
+  if (ErrorCode)
+    llvm::report_fatal_error("cannot open out file: " + OutputFilename);
+  if (auto Err = Analyzer.run<Pass>(ClustersOS))
+    llvm::report_fatal_error(std::move(Err));
+}
+
+static void analysisMain() {
   // Read benchmarks.
   const std::vector<InstructionBenchmark> Points =
       InstructionBenchmark::readYamlsOrDie(BenchmarkFile);
   llvm::outs() << "Parsed " << Points.size() << " benchmark points\n";
   if (Points.empty()) {
     llvm::errs() << "no benchmarks to analyze\n";
     return;
   }
if (!TheTarget) {
     llvm::errs() << "unknown target '" << Points[0].LLVMTriple << "'\n";
     return;
   }
   const auto Clustering = llvm::cantFail(InstructionBenchmarkClustering::create(
       Points, AnalysisNumPoints, AnalysisEpsilon));
 
   const Analysis Analyzer(*TheTarget, Clustering);
 
-  std::error_code ErrorCode;
-  llvm::raw_fd_ostream ClustersOS(AnalysisClustersFile, ErrorCode,
-                                  llvm::sys::fs::F_RW);
-  if (ErrorCode)
-    llvm::report_fatal_error("cannot open out file: " + AnalysisClustersFile);
-
-  if (auto Err = Analyzer.printClusters(ClustersOS))
-    llvm::report_fatal_error(std::move(Err));
-
-  if (auto Err = Analyzer.printSchedClassInconsistencies(llvm::outs()))
-    llvm::report_fatal_error(std::move(Err));
+  maybeRunAnalysis<Analysis::PrintClusters>(Analyzer, "analysis clusters",
+                                            AnalysisClustersOutputFile);
+  maybeRunAnalysis<Analysis::PrintSchedClassInconsistencies>(
+      Analyzer, "sched class consistency analysis",
+      AnalysisInconsistenciesOutputFile);
 }
 
 } // namespace exegesis
 
 int main(int Argc, char **Argv) {
   llvm::cl::ParseCommandLineOptions(Argc, Argv, "");
 
   if (BenchmarkMode == BenchmarkModeE::Analysis) {
     exegesis::analysisMain();
   } else {
     exegesis::benchmarkMain();
   }
   return EXIT_SUCCESS;
 }