[llvm-exegesis] Improve error reporting in BenchmarkRunner.cpp

[mstojanovic]

Summary

Followup to D74085.
Replace the use of report_fatal_error() with returning the error to llvm-exegesis.cpp and handling it there.
To facilitate this, a new Error type has been added which is only used to log errors to the yaml output.

[courbet]

llvm/tools/llvm-exegesis/lib/Error.h

65

please run clang-format on the patch.

[mstojanovic]

Formatted patch.

llvm/tools/llvm-exegesis/lib/BenchmarkRunner.h

 // Common code for all benchmark modes.
 class BenchmarkRunner {
 public:
   explicit BenchmarkRunner(const LLVMState &State,
                            InstructionBenchmark::ModeE Mode);
 
   virtual ~BenchmarkRunner();
 
-  InstructionBenchmark runConfiguration(const BenchmarkCode &Configuration,
-                                        unsigned NumRepetitions,
-                                        const SnippetRepetitor &Repetitor,
-                                        bool DumpObjectToDisk) const;
+  Expected<InstructionBenchmark>
+  runConfiguration(const BenchmarkCode &Configuration, unsigned NumRepetitions,
 
   // Scratch space to run instructions that touch memory.
   struct ScratchSpace {
     static constexpr const size_t kAlignment = 1024;
     static constexpr const size_t kSize = 1 << 20; // 1MB.
     ScratchSpace()
         : UnalignedPtr(std::make_unique<char[]>(kSize + kAlignment)),
           AlignedPtr(

llvm/tools/llvm-exegesis/lib/BenchmarkRunner.cpp

Expected<int64_t> runAndMeasure(const char *Counters) const override {
     int64_t CounterValue = 0;
     SmallVector<StringRef, 2> CounterNames;
     StringRef(Counters).split(CounterNames, '+');
     char *const ScratchPtr = Scratch->ptr();
     for (auto &CounterName : CounterNames) {
       CounterName = CounterName.trim();
       pfm::PerfEvent PerfEvent(CounterName);
       if (!PerfEvent.valid())
-        report_fatal_error(
+        return make_error<Failure>(
             Twine("invalid perf event '").concat(CounterName).concat("'"));
       pfm::Counter Counter(PerfEvent);
       Scratch->clear();
       {
         CrashRecoveryContext CRC;
         CrashRecoveryContext::Enable();
         const bool Crashed = !CRC.RunSafely([this, &Counter, ScratchPtr]() {
           Counter.start();
           this->Function(ScratchPtr);
           Counter.stop();
         });
         CrashRecoveryContext::Disable();
         // FIXME: Better diagnosis.
         if (Crashed)
-          return make_error<Failure>("snippet crashed while running");
+          return make_error<SnippetCrash>("snippet crashed while running");
       }
       CounterValue += Counter.read();
     }
     return CounterValue;
   }
 
   const ExecutableFunction Function;
   BenchmarkRunner::ScratchSpace *const Scratch;
 };
 } // namespace
 
-InstructionBenchmark BenchmarkRunner::runConfiguration(
+Expected<InstructionBenchmark> BenchmarkRunner::runConfiguration(
     const BenchmarkCode &BC, unsigned NumRepetitions,
     const SnippetRepetitor &Repetitor, bool DumpObjectToDisk) const {
   InstructionBenchmark InstrBenchmark;
   InstrBenchmark.Mode = Mode;
   InstrBenchmark.CpuName = std::string(State.getTargetMachine().getTargetCPU());
   InstrBenchmark.LLVMTriple =
       State.getTargetMachine().getTargetTriple().normalize();
   InstrBenchmark.NumRepetitions = NumRepetitions;
assembleToStream(State.getExegesisTarget(), State.createTargetMachine(),
                      BC.LiveIns, BC.Key.RegisterInitialValues, Filler, OS);
     ObjectFile = getObjectFromBuffer(OS.str());
   }
 
   const FunctionExecutorImpl Executor(State, std::move(ObjectFile),
                                       Scratch.get());
   auto Measurements = runMeasurements(Executor);
   if (Error E = Measurements.takeError()) {
+    if (!E.isA<SnippetCrash>())
+      return std::move(E);
     InstrBenchmark.Error = toString(std::move(E));
     return InstrBenchmark;
   }
   InstrBenchmark.Measurements = std::move(*Measurements);
   assert(InstrBenchmark.NumRepetitions > 0 && "invalid NumRepetitions");
   for (BenchmarkMeasure &BM : InstrBenchmark.Measurements) {
     // Scale the measurements by instruction.
     BM.PerInstructionValue /= InstrBenchmark.NumRepetitions;

llvm/tools/llvm-exegesis/lib/Error.h

 public:
   Failure(const Twine &S) : StringError(S, inconvertibleErrorCode()) {}
 };
 
 // A class representing failures that happened during clustering calculations.
 class ClusteringError : public ErrorInfo<ClusteringError> {
 public:
   static char ID;
-  ClusteringError(const Twine&S) : Msg(S.str()) {}
+  ClusteringError(const Twine &S) : Msg(S.str()) {}
 
   void log(raw_ostream &OS) const override;
 
   std::error_code convertToErrorCode() const override;
+
+private:
+  std::string Msg;
+};
+
+// A class representing failures that happened during snippet execution.
+// Instead of terminating the program crashes are logged into the output.
+class SnippetCrash : public ErrorInfo<SnippetCrash> {
+public:
+  static char ID;
+  SnippetCrash(const Twine &S) : Msg(S.str()) {}
+
+  void log(raw_ostream &OS) const override;
+
+  std::error_code convertToErrorCode() const override;
+
 private:
-    std::string Msg;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif

llvm/tools/llvm-exegesis/lib/Error.cpp

 //===-- Error.cpp -----------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
 
 namespace llvm {
 namespace exegesis {
 
 char ClusteringError::ID;
 
-void ClusteringError::log(raw_ostream &OS) const {
-  OS << Msg;
-}
+void ClusteringError::log(raw_ostream &OS) const { OS << Msg; }
 
 std::error_code ClusteringError::convertToErrorCode() const {
   return inconvertibleErrorCode();
 }
 
+char SnippetCrash::ID;
+
+void SnippetCrash::log(raw_ostream &OS) const { OS << Msg; }
+
+std::error_code SnippetCrash::convertToErrorCode() const {
+  return inconvertibleErrorCode();
+}
+
 } // namespace exegesis
 } // namespace llvm

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

if (NumRepetitions == 0) {
     ExitWithError("--num-repetitions must be greater than zero");
   }
 
   // Write to standard output if file is not set.
   if (BenchmarkFile.empty())
     BenchmarkFile = "-";
 
   for (const BenchmarkCode &Conf : Configurations) {
-    InstructionBenchmark Result = Runner->runConfiguration(
-        Conf, NumRepetitions, *Repetitor, DumpObjectToDisk);
+    InstructionBenchmark Result = ExitOnErr(Runner->runConfiguration(
+        Conf, NumRepetitions, *Repetitor, DumpObjectToDisk));
     ExitOnFileError(BenchmarkFile, Result.writeYaml(State, BenchmarkFile));
   }
   exegesis::pfm::pfmTerminate();
 }
 
 // Prints the results of running analysis pass `Pass` to file `OutputFilename`
 // if OutputFilename is non-empty.
 template <typename Pass>