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

   1 //===-- BenchmarkRunner.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 <array>
  10 #include <memory>
  11 #include <string>
  12
  13 #include "Assembler.h"
  14 #include "BenchmarkRunner.h"
  15 #include "Error.h"
  16 #include "MCInstrDescView.h"
  17 #include "PerfHelper.h"
  18 #include "Target.h"
  19 #include "llvm/ADT/ScopeExit.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/ADT/Twine.h"
  23 #include "llvm/Support/CrashRecoveryContext.h"
  24 #include "llvm/Support/Error.h"
  25 #include "llvm/Support/FileSystem.h"
  26 #include "llvm/Support/MemoryBuffer.h"
  27 #include "llvm/Support/Program.h"
  28
  29 namespace llvm {
  30 namespace exegesis {
  31
  32 BenchmarkRunner::BenchmarkRunner(const LLVMState &State,
  33                                  InstructionBenchmark::ModeE Mode)
  34     : State(State), Mode(Mode), Scratch(std::make_unique<ScratchSpace>()) {}
  35
  36 BenchmarkRunner::~BenchmarkRunner() = default;
  37
  38 namespace {
  39 class FunctionExecutorImpl : public BenchmarkRunner::FunctionExecutor {
  40 public:
  41   FunctionExecutorImpl(const LLVMState &State,
  42                        object::OwningBinary<object::ObjectFile> Obj,
  43                        BenchmarkRunner::ScratchSpace *Scratch)
  44       : State(State), Function(State.createTargetMachine(), std::move(Obj)),
  45         Scratch(Scratch) {}
  46
  47 private:
  48   Expected<int64_t> runAndMeasure(const char *Counters) const override {
  49     auto ResultOrError = runAndSample(Counters);
  50     if (ResultOrError)
  51       return ResultOrError.get()[0];
  52     return ResultOrError.takeError();
  53   }
  54
  55   static void
  56   accumulateCounterValues(const llvm::SmallVector<int64_t, 4> &NewValues,
  57                           llvm::SmallVector<int64_t, 4> *Result) {
  58     const size_t NumValues = std::max(NewValues.size(), Result->size());
  59     if (NumValues > Result->size())
  60       Result->resize(NumValues, 0);
  61     for (size_t I = 0, End = NewValues.size(); I < End; ++I)
  62       (*Result)[I] += NewValues[I];
  63   }
  64
  65   Expected<llvm::SmallVector<int64_t, 4>>
  66   runAndSample(const char *Counters) const override {
  67     // We sum counts when there are several counters for a single ProcRes
  68     // (e.g. P23 on SandyBridge).
  69     llvm::SmallVector<int64_t, 4> CounterValues;
  70     int Reserved = 0;
  71     SmallVector<StringRef, 2> CounterNames;
  72     StringRef(Counters).split(CounterNames, '+');
  73     char *const ScratchPtr = Scratch->ptr();
  74     const ExegesisTarget &ET = State.getExegesisTarget();
  75     for (auto &CounterName : CounterNames) {
  76       CounterName = CounterName.trim();
  77       auto CounterOrError = ET.createCounter(CounterName, State);
  78
  79       if (!CounterOrError)
  80         return CounterOrError.takeError();
  81
  82       pfm::Counter *Counter = CounterOrError.get().get();
  83       if (Reserved == 0) {
  84         Reserved = Counter->numValues();
  85         CounterValues.reserve(Reserved);
  86       } else if (Reserved != Counter->numValues())
  87         // It'd be wrong to accumulate vectors of different sizes.
  88         return make_error<Failure>(
  89             llvm::Twine("Inconsistent number of values for counter ")
  90                 .concat(CounterName)
  91                 .concat(std::to_string(Counter->numValues()))
  92                 .concat(" vs expected of ")
  93                 .concat(std::to_string(Reserved)));
  94       Scratch->clear();
  95       {
  96         auto PS = ET.withSavedState();
  97         CrashRecoveryContext CRC;
  98         CrashRecoveryContext::Enable();
  99         const bool Crashed = !CRC.RunSafely([this, Counter, ScratchPtr]() {
 100           Counter->start();
 101           this->Function(ScratchPtr);
 102           Counter->stop();
 103         });
 104         CrashRecoveryContext::Disable();
 105         PS.reset();
 106         if (Crashed) {
 107           std::string Msg = "snippet crashed while running";
 108 #ifdef LLVM_ON_UNIX
 109           // See "Exit Status for Commands":
 110           // https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xcu_chap02.html
 111           constexpr const int kSigOffset = 128;
 112           if (const char *const SigName = strsignal(CRC.RetCode - kSigOffset)) {
 113             Msg += ": ";
 114             Msg += SigName;
 115           }
 116 #endif
 117           return make_error<SnippetCrash>(std::move(Msg));
 118         }
 119       }
 120
 121       auto ValueOrError = Counter->readOrError(Function.getFunctionBytes());
 122       if (!ValueOrError)
 123         return ValueOrError.takeError();
 124       accumulateCounterValues(ValueOrError.get(), &CounterValues);
 125     }
 126     return CounterValues;
 127   }
 128
 129   const LLVMState &State;
 130   const ExecutableFunction Function;
 131   BenchmarkRunner::ScratchSpace *const Scratch;
 132 };
 133 } // namespace
 134
 135 Expected<InstructionBenchmark> BenchmarkRunner::runConfiguration(
 136     const BenchmarkCode &BC, unsigned NumRepetitions, unsigned LoopBodySize,
 137     ArrayRef<std::unique_ptr<const SnippetRepetitor>> Repetitors,
 138     bool DumpObjectToDisk) const {
 139   InstructionBenchmark InstrBenchmark;
 140   InstrBenchmark.Mode = Mode;
 141   InstrBenchmark.CpuName = std::string(State.getTargetMachine().getTargetCPU());
 142   InstrBenchmark.LLVMTriple =
 143       State.getTargetMachine().getTargetTriple().normalize();
 144   InstrBenchmark.NumRepetitions = NumRepetitions;
 145   InstrBenchmark.Info = BC.Info;
 146
 147   const std::vector<MCInst> &Instructions = BC.Key.Instructions;
 148
 149   InstrBenchmark.Key = BC.Key;
 150
 151   // If we end up having an error, and we've previously succeeded with
 152   // some other Repetitor, we want to discard the previous measurements.
 153   struct ClearBenchmarkOnReturn {
 154     ClearBenchmarkOnReturn(InstructionBenchmark *IB) : IB(IB) {}
 155     ~ClearBenchmarkOnReturn() {
 156       if (Clear)
 157         IB->Measurements.clear();
 158     }
 159     void disarm() { Clear = false; }
 160
 161   private:
 162     InstructionBenchmark *const IB;
 163     bool Clear = true;
 164   };
 165   ClearBenchmarkOnReturn CBOR(&InstrBenchmark);
 166
 167   for (const std::unique_ptr<const SnippetRepetitor> &Repetitor : Repetitors) {
 168     // Assemble at least kMinInstructionsForSnippet instructions by repeating
 169     // the snippet for debug/analysis. This is so that the user clearly
 170     // understands that the inside instructions are repeated.
 171     const int MinInstructionsForSnippet = 4 * Instructions.size();
 172     const int LoopBodySizeForSnippet = 2 * Instructions.size();
 173     {
 174       SmallString<0> Buffer;
 175       raw_svector_ostream OS(Buffer);
 176       if (Error E = assembleToStream(
 177               State.getExegesisTarget(), State.createTargetMachine(),
 178               BC.LiveIns, BC.Key.RegisterInitialValues,
 179               Repetitor->Repeat(Instructions, MinInstructionsForSnippet,
 180                                 LoopBodySizeForSnippet),
 181               OS)) {
 182         return std::move(E);
 183       }
 184       const ExecutableFunction EF(State.createTargetMachine(),
 185                                   getObjectFromBuffer(OS.str()));
 186       const auto FnBytes = EF.getFunctionBytes();
 187       llvm::append_range(InstrBenchmark.AssembledSnippet, FnBytes);
 188     }
 189
 190     // Assemble NumRepetitions instructions repetitions of the snippet for
 191     // measurements.
 192     const auto Filler = Repetitor->Repeat(
 193         Instructions, InstrBenchmark.NumRepetitions, LoopBodySize);
 194
 195     object::OwningBinary<object::ObjectFile> ObjectFile;
 196     if (DumpObjectToDisk) {
 197       auto ObjectFilePath = writeObjectFile(BC, Filler);
 198       if (Error E = ObjectFilePath.takeError()) {
 199         InstrBenchmark.Error = toString(std::move(E));
 200         return InstrBenchmark;
 201       }
 202       outs() << "Check generated assembly with: /usr/bin/objdump -d "
 203              << *ObjectFilePath << "\n";
 204       ObjectFile = getObjectFromFile(*ObjectFilePath);
 205     } else {
 206       SmallString<0> Buffer;
 207       raw_svector_ostream OS(Buffer);
 208       if (Error E = assembleToStream(
 209               State.getExegesisTarget(), State.createTargetMachine(),
 210               BC.LiveIns, BC.Key.RegisterInitialValues, Filler, OS)) {
 211         return std::move(E);
 212       }
 213       ObjectFile = getObjectFromBuffer(OS.str());
 214     }
 215
 216     const FunctionExecutorImpl Executor(State, std::move(ObjectFile),
 217                                         Scratch.get());
 218     auto NewMeasurements = runMeasurements(Executor);
 219     if (Error E = NewMeasurements.takeError()) {
 220       if (!E.isA<SnippetCrash>())
 221         return std::move(E);
 222       InstrBenchmark.Error = toString(std::move(E));
 223       return InstrBenchmark;
 224     }
 225     assert(InstrBenchmark.NumRepetitions > 0 && "invalid NumRepetitions");
 226     for (BenchmarkMeasure &BM : *NewMeasurements) {
 227       // Scale the measurements by instruction.
 228       BM.PerInstructionValue /= InstrBenchmark.NumRepetitions;
 229       // Scale the measurements by snippet.
 230       BM.PerSnippetValue *= static_cast<double>(Instructions.size()) /
 231                             InstrBenchmark.NumRepetitions;
 232     }
 233     if (InstrBenchmark.Measurements.empty()) {
 234       InstrBenchmark.Measurements = std::move(*NewMeasurements);
 235       continue;
 236     }
 237
 238     assert(Repetitors.size() > 1 && !InstrBenchmark.Measurements.empty() &&
 239            "We're in an 'min' repetition mode, and need to aggregate new "
 240            "result to the existing result.");
 241     assert(InstrBenchmark.Measurements.size() == NewMeasurements->size() &&
 242            "Expected to have identical number of measurements.");
 243     for (auto I : zip(InstrBenchmark.Measurements, *NewMeasurements)) {
 244       BenchmarkMeasure &Measurement = std::get<0>(I);
 245       BenchmarkMeasure &NewMeasurement = std::get<1>(I);
 246       assert(Measurement.Key == NewMeasurement.Key &&
 247              "Expected measurements to be symmetric");
 248
 249       Measurement.PerInstructionValue = std::min(
 250           Measurement.PerInstructionValue, NewMeasurement.PerInstructionValue);
 251       Measurement.PerSnippetValue =
 252           std::min(Measurement.PerSnippetValue, NewMeasurement.PerSnippetValue);
 253     }
 254   }
 255
 256   // We successfully measured everything, so don't discard the results.
 257   CBOR.disarm();
 258   return InstrBenchmark;
 259 }
 260
 261 Expected<std::string>
 262 BenchmarkRunner::writeObjectFile(const BenchmarkCode &BC,
 263                                  const FillFunction &FillFunction) const {
 264   int ResultFD = 0;
 265   SmallString<256> ResultPath;
 266   if (Error E = errorCodeToError(
 267           sys::fs::createTemporaryFile("snippet", "o", ResultFD, ResultPath)))
 268     return std::move(E);
 269   raw_fd_ostream OFS(ResultFD, true /*ShouldClose*/);
 270   if (Error E = assembleToStream(
 271           State.getExegesisTarget(), State.createTargetMachine(), BC.LiveIns,
 272           BC.Key.RegisterInitialValues, FillFunction, OFS)) {
 273     return std::move(E);
 274   }
 275   return std::string(ResultPath.str());
 276 }
 277
 278 BenchmarkRunner::FunctionExecutor::~FunctionExecutor() {}
 279
 280 } // namespace exegesis
 281 } // namespace llvm