tools/llvm-exegesis/lib/BenchmarkResult.cpp

   1 //===-- BenchmarkResult.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 "BenchmarkResult.h"
  10 #include "BenchmarkRunner.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/ScopeExit.h"
  13 #include "llvm/ADT/StringMap.h"
  14 #include "llvm/ADT/StringRef.h"
  15 #include "llvm/ADT/bit.h"
  16 #include "llvm/ObjectYAML/YAML.h"
  17 #include "llvm/Support/FileOutputBuffer.h"
  18 #include "llvm/Support/FileSystem.h"
  19 #include "llvm/Support/Format.h"
  20 #include "llvm/Support/raw_ostream.h"
  21
  22 static constexpr const char kIntegerPrefix[] = "i_0x";
  23 static constexpr const char kDoublePrefix[] = "f_";
  24 static constexpr const char kInvalidOperand[] = "INVALID";
  25 static constexpr llvm::StringLiteral kNoRegister("%noreg");
  26
  27 namespace llvm {
  28
  29 namespace {
  30
  31 // A mutable struct holding an LLVMState that can be passed through the
  32 // serialization process to encode/decode registers and instructions.
  33 struct YamlContext {
  34   YamlContext(const exegesis::LLVMState &State)
  35       : State(&State), ErrorStream(LastError),
  36         OpcodeNameToOpcodeIdx(
  37             generateOpcodeNameToOpcodeIdxMapping(State.getInstrInfo())),
  38         RegNameToRegNo(generateRegNameToRegNoMapping(State.getRegInfo())) {}
  39
  40   static llvm::StringMap<unsigned>
  41   generateOpcodeNameToOpcodeIdxMapping(const llvm::MCInstrInfo &InstrInfo) {
  42     llvm::StringMap<unsigned> Map(InstrInfo.getNumOpcodes());
  43     for (unsigned I = 0, E = InstrInfo.getNumOpcodes(); I < E; ++I)
  44       Map[InstrInfo.getName(I)] = I;
  45     assert(Map.size() == InstrInfo.getNumOpcodes() && "Size prediction failed");
  46     return Map;
  47   };
  48
  49   llvm::StringMap<unsigned>
  50   generateRegNameToRegNoMapping(const llvm::MCRegisterInfo &RegInfo) {
  51     llvm::StringMap<unsigned> Map(RegInfo.getNumRegs());
  52     // Special-case RegNo 0, which would otherwise be spelled as ''.
  53     Map[kNoRegister] = 0;
  54     for (unsigned I = 1, E = RegInfo.getNumRegs(); I < E; ++I)
  55       Map[RegInfo.getName(I)] = I;
  56     assert(Map.size() == RegInfo.getNumRegs() && "Size prediction failed");
  57     return Map;
  58   };
  59
  60   void serializeMCInst(const llvm::MCInst &MCInst, llvm::raw_ostream &OS) {
  61     OS << getInstrName(MCInst.getOpcode());
  62     for (const auto &Op : MCInst) {
  63       OS << ' ';
  64       serializeMCOperand(Op, OS);
  65     }
  66   }
  67
  68   void deserializeMCInst(llvm::StringRef String, llvm::MCInst &Value) {
  69     llvm::SmallVector<llvm::StringRef, 16> Pieces;
  70     String.split(Pieces, " ", /* MaxSplit */ -1, /* KeepEmpty */ false);
  71     if (Pieces.empty()) {
  72       ErrorStream << "Unknown Instruction: '" << String << "'\n";
  73       return;
  74     }
  75     bool ProcessOpcode = true;
  76     for (llvm::StringRef Piece : Pieces) {
  77       if (ProcessOpcode)
  78         Value.setOpcode(getInstrOpcode(Piece));
  79       else
  80         Value.addOperand(deserializeMCOperand(Piece));
  81       ProcessOpcode = false;
  82     }
  83   }
  84
  85   std::string &getLastError() { return ErrorStream.str(); }
  86
  87   llvm::raw_string_ostream &getErrorStream() { return ErrorStream; }
  88
  89   llvm::StringRef getRegName(unsigned RegNo) {
  90     // Special case: RegNo 0 is NoRegister. We have to deal with it explicitly.
  91     if (RegNo == 0)
  92       return kNoRegister;
  93     const llvm::StringRef RegName = State->getRegInfo().getName(RegNo);
  94     if (RegName.empty())
  95       ErrorStream << "No register with enum value '" << RegNo << "'\n";
  96     return RegName;
  97   }
  98
  99   llvm::Optional<unsigned> getRegNo(llvm::StringRef RegName) {
 100     auto Iter = RegNameToRegNo.find(RegName);
 101     if (Iter != RegNameToRegNo.end())
 102       return Iter->second;
 103     ErrorStream << "No register with name '" << RegName << "'\n";
 104     return llvm::None;
 105   }
 106
 107 private:
 108   void serializeIntegerOperand(llvm::raw_ostream &OS, int64_t Value) {
 109     OS << kIntegerPrefix;
 110     OS.write_hex(llvm::bit_cast<uint64_t>(Value));
 111   }
 112
 113   bool tryDeserializeIntegerOperand(llvm::StringRef String, int64_t &Value) {
 114     if (!String.consume_front(kIntegerPrefix))
 115       return false;
 116     return !String.consumeInteger(16, Value);
 117   }
 118
 119   void serializeFPOperand(llvm::raw_ostream &OS, double Value) {
 120     OS << kDoublePrefix << llvm::format("%la", Value);
 121   }
 122
 123   bool tryDeserializeFPOperand(llvm::StringRef String, double &Value) {
 124     if (!String.consume_front(kDoublePrefix))
 125       return false;
 126     char *EndPointer = nullptr;
 127     Value = strtod(String.begin(), &EndPointer);
 128     return EndPointer == String.end();
 129   }
 130
 131   void serializeMCOperand(const llvm::MCOperand &MCOperand,
 132                           llvm::raw_ostream &OS) {
 133     if (MCOperand.isReg()) {
 134       OS << getRegName(MCOperand.getReg());
 135     } else if (MCOperand.isImm()) {
 136       serializeIntegerOperand(OS, MCOperand.getImm());
 137     } else if (MCOperand.isFPImm()) {
 138       serializeFPOperand(OS, MCOperand.getFPImm());
 139     } else {
 140       OS << kInvalidOperand;
 141     }
 142   }
 143
 144   llvm::MCOperand deserializeMCOperand(llvm::StringRef String) {
 145     assert(!String.empty());
 146     int64_t IntValue = 0;
 147     double DoubleValue = 0;
 148     if (tryDeserializeIntegerOperand(String, IntValue))
 149       return llvm::MCOperand::createImm(IntValue);
 150     if (tryDeserializeFPOperand(String, DoubleValue))
 151       return llvm::MCOperand::createFPImm(DoubleValue);
 152     if (auto RegNo = getRegNo(String))
 153       return llvm::MCOperand::createReg(*RegNo);
 154     if (String != kInvalidOperand)
 155       ErrorStream << "Unknown Operand: '" << String << "'\n";
 156     return {};
 157   }
 158
 159   llvm::StringRef getInstrName(unsigned InstrNo) {
 160     const llvm::StringRef InstrName = State->getInstrInfo().getName(InstrNo);
 161     if (InstrName.empty())
 162       ErrorStream << "No opcode with enum value '" << InstrNo << "'\n";
 163     return InstrName;
 164   }
 165
 166   unsigned getInstrOpcode(llvm::StringRef InstrName) {
 167     auto Iter = OpcodeNameToOpcodeIdx.find(InstrName);
 168     if (Iter != OpcodeNameToOpcodeIdx.end())
 169       return Iter->second;
 170     ErrorStream << "No opcode with name '" << InstrName << "'\n";
 171     return 0;
 172   }
 173
 174   const llvm::exegesis::LLVMState *State;
 175   std::string LastError;
 176   llvm::raw_string_ostream ErrorStream;
 177   const llvm::StringMap<unsigned> OpcodeNameToOpcodeIdx;
 178   const llvm::StringMap<unsigned> RegNameToRegNo;
 179 };
 180 } // namespace
 181
 182 // Defining YAML traits for IO.
 183 namespace yaml {
 184
 185 static YamlContext &getTypedContext(void *Ctx) {
 186   return *reinterpret_cast<YamlContext *>(Ctx);
 187 }
 188
 189 // std::vector<llvm::MCInst> will be rendered as a list.
 190 template <> struct SequenceElementTraits<llvm::MCInst> {
 191   static const bool flow = false;
 192 };
 193
 194 template <> struct ScalarTraits<llvm::MCInst> {
 195
 196   static void output(const llvm::MCInst &Value, void *Ctx,
 197                      llvm::raw_ostream &Out) {
 198     getTypedContext(Ctx).serializeMCInst(Value, Out);
 199   }
 200
 201   static StringRef input(StringRef Scalar, void *Ctx, llvm::MCInst &Value) {
 202     YamlContext &Context = getTypedContext(Ctx);
 203     Context.deserializeMCInst(Scalar, Value);
 204     return Context.getLastError();
 205   }
 206
 207   // By default strings are quoted only when necessary.
 208   // We force the use of single quotes for uniformity.
 209   static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 210
 211   static const bool flow = true;
 212 };
 213
 214 // std::vector<exegesis::Measure> will be rendered as a list.
 215 template <> struct SequenceElementTraits<exegesis::BenchmarkMeasure> {
 216   static const bool flow = false;
 217 };
 218
 219 // exegesis::Measure is rendererd as a flow instead of a list.
 220 // e.g. { "key": "the key", "value": 0123 }
 221 template <> struct MappingTraits<exegesis::BenchmarkMeasure> {
 222   static void mapping(IO &Io, exegesis::BenchmarkMeasure &Obj) {
 223     Io.mapRequired("key", Obj.Key);
 224     if (!Io.outputting()) {
 225       // For backward compatibility, interpret debug_string as a key.
 226       Io.mapOptional("debug_string", Obj.Key);
 227     }
 228     Io.mapRequired("value", Obj.PerInstructionValue);
 229     Io.mapOptional("per_snippet_value", Obj.PerSnippetValue);
 230   }
 231   static const bool flow = true;
 232 };
 233
 234 template <>
 235 struct ScalarEnumerationTraits<exegesis::InstructionBenchmark::ModeE> {
 236   static void enumeration(IO &Io,
 237                           exegesis::InstructionBenchmark::ModeE &Value) {
 238     Io.enumCase(Value, "", exegesis::InstructionBenchmark::Unknown);
 239     Io.enumCase(Value, "latency", exegesis::InstructionBenchmark::Latency);
 240     Io.enumCase(Value, "uops", exegesis::InstructionBenchmark::Uops);
 241     Io.enumCase(Value, "inverse_throughput",
 242                 exegesis::InstructionBenchmark::InverseThroughput);
 243   }
 244 };
 245
 246 // std::vector<exegesis::RegisterValue> will be rendered as a list.
 247 template <> struct SequenceElementTraits<exegesis::RegisterValue> {
 248   static const bool flow = false;
 249 };
 250
 251 template <> struct ScalarTraits<exegesis::RegisterValue> {
 252   static constexpr const unsigned kRadix = 16;
 253   static constexpr const bool kSigned = false;
 254
 255   static void output(const exegesis::RegisterValue &RV, void *Ctx,
 256                      llvm::raw_ostream &Out) {
 257     YamlContext &Context = getTypedContext(Ctx);
 258     Out << Context.getRegName(RV.Register) << "=0x"
 259         << RV.Value.toString(kRadix, kSigned);
 260   }
 261
 262   static StringRef input(StringRef String, void *Ctx,
 263                          exegesis::RegisterValue &RV) {
 264     llvm::SmallVector<llvm::StringRef, 2> Pieces;
 265     String.split(Pieces, "=0x", /* MaxSplit */ -1,
 266                  /* KeepEmpty */ false);
 267     YamlContext &Context = getTypedContext(Ctx);
 268     llvm::Optional<unsigned> RegNo;
 269     if (Pieces.size() == 2 && (RegNo = Context.getRegNo(Pieces[0]))) {
 270       RV.Register = *RegNo;
 271       const unsigned BitsNeeded = llvm::APInt::getBitsNeeded(Pieces[1], kRadix);
 272       RV.Value = llvm::APInt(BitsNeeded, Pieces[1], kRadix);
 273     } else {
 274       Context.getErrorStream()
 275           << "Unknown initial register value: '" << String << "'";
 276     }
 277     return Context.getLastError();
 278   }
 279
 280   static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 281
 282   static const bool flow = true;
 283 };
 284
 285 template <>
 286 struct MappingContextTraits<exegesis::InstructionBenchmarkKey, YamlContext> {
 287   static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj,
 288                       YamlContext &Context) {
 289     Io.setContext(&Context);
 290     Io.mapRequired("instructions", Obj.Instructions);
 291     Io.mapOptional("config", Obj.Config);
 292     Io.mapRequired("register_initial_values", Obj.RegisterInitialValues);
 293   }
 294 };
 295
 296 template <>
 297 struct MappingContextTraits<exegesis::InstructionBenchmark, YamlContext> {
 298   struct NormalizedBinary {
 299     NormalizedBinary(IO &io) {}
 300     NormalizedBinary(IO &, std::vector<uint8_t> &Data) : Binary(Data) {}
 301     std::vector<uint8_t> denormalize(IO &) {
 302       std::vector<uint8_t> Data;
 303       std::string Str;
 304       raw_string_ostream OSS(Str);
 305       Binary.writeAsBinary(OSS);
 306       OSS.flush();
 307       Data.assign(Str.begin(), Str.end());
 308       return Data;
 309     }
 310
 311     BinaryRef Binary;
 312   };
 313
 314   static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj,
 315                       YamlContext &Context) {
 316     Io.mapRequired("mode", Obj.Mode);
 317     Io.mapRequired("key", Obj.Key, Context);
 318     Io.mapRequired("cpu_name", Obj.CpuName);
 319     Io.mapRequired("llvm_triple", Obj.LLVMTriple);
 320     Io.mapRequired("num_repetitions", Obj.NumRepetitions);
 321     Io.mapRequired("measurements", Obj.Measurements);
 322     Io.mapRequired("error", Obj.Error);
 323     Io.mapOptional("info", Obj.Info);
 324     // AssembledSnippet
 325     MappingNormalization<NormalizedBinary, std::vector<uint8_t>> BinaryString(
 326         Io, Obj.AssembledSnippet);
 327     Io.mapOptional("assembled_snippet", BinaryString->Binary);
 328   }
 329 };
 330
 331 } // namespace yaml
 332
 333 namespace exegesis {
 334
 335 llvm::Expected<InstructionBenchmark>
 336 InstructionBenchmark::readYaml(const LLVMState &State,
 337                                llvm::StringRef Filename) {
 338   if (auto ExpectedMemoryBuffer =
 339           llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename))) {
 340     llvm::yaml::Input Yin(*ExpectedMemoryBuffer.get());
 341     YamlContext Context(State);
 342     InstructionBenchmark Benchmark;
 343     if (Yin.setCurrentDocument())
 344       llvm::yaml::yamlize(Yin, Benchmark, /*unused*/ true, Context);
 345     if (!Context.getLastError().empty())
 346       return llvm::make_error<BenchmarkFailure>(Context.getLastError());
 347     return Benchmark;
 348   } else {
 349     return ExpectedMemoryBuffer.takeError();
 350   }
 351 }
 352
 353 llvm::Expected<std::vector<InstructionBenchmark>>
 354 InstructionBenchmark::readYamls(const LLVMState &State,
 355                                 llvm::StringRef Filename) {
 356   if (auto ExpectedMemoryBuffer =
 357           llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename))) {
 358     llvm::yaml::Input Yin(*ExpectedMemoryBuffer.get());
 359     YamlContext Context(State);
 360     std::vector<InstructionBenchmark> Benchmarks;
 361     while (Yin.setCurrentDocument()) {
 362       Benchmarks.emplace_back();
 363       yamlize(Yin, Benchmarks.back(), /*unused*/ true, Context);
 364       if (Yin.error())
 365         return llvm::errorCodeToError(Yin.error());
 366       if (!Context.getLastError().empty())
 367         return llvm::make_error<BenchmarkFailure>(Context.getLastError());
 368       Yin.nextDocument();
 369     }
 370     return Benchmarks;
 371   } else {
 372     return ExpectedMemoryBuffer.takeError();
 373   }
 374 }
 375
 376 llvm::Error InstructionBenchmark::writeYamlTo(const LLVMState &State,
 377                                               llvm::raw_ostream &OS) {
 378   auto Cleanup = make_scope_exit([&] { OS.flush(); });
 379   llvm::yaml::Output Yout(OS, nullptr /*Ctx*/, 200 /*WrapColumn*/);
 380   YamlContext Context(State);
 381   Yout.beginDocuments();
 382   llvm::yaml::yamlize(Yout, *this, /*unused*/ true, Context);
 383   if (!Context.getLastError().empty())
 384     return llvm::make_error<BenchmarkFailure>(Context.getLastError());
 385   Yout.endDocuments();
 386   return Error::success();
 387 }
 388
 389 llvm::Error InstructionBenchmark::readYamlFrom(const LLVMState &State,
 390                                                llvm::StringRef InputContent) {
 391   llvm::yaml::Input Yin(InputContent);
 392   YamlContext Context(State);
 393   if (Yin.setCurrentDocument())
 394     llvm::yaml::yamlize(Yin, *this, /*unused*/ true, Context);
 395   if (!Context.getLastError().empty())
 396     return llvm::make_error<BenchmarkFailure>(Context.getLastError());
 397   return Error::success();
 398 }
 399
 400 llvm::Error InstructionBenchmark::writeYaml(const LLVMState &State,
 401                                             const llvm::StringRef Filename) {
 402   if (Filename == "-") {
 403     if (auto Err = writeYamlTo(State, llvm::outs()))
 404       return Err;
 405   } else {
 406     int ResultFD = 0;
 407     if (auto E = llvm::errorCodeToError(
 408             openFileForWrite(Filename, ResultFD, llvm::sys::fs::CD_CreateAlways,
 409                              llvm::sys::fs::OF_Text))) {
 410       return E;
 411     }
 412     llvm::raw_fd_ostream Ostr(ResultFD, true /*shouldClose*/);
 413     if (auto Err = writeYamlTo(State, Ostr))
 414       return Err;
 415   }
 416   return llvm::Error::success();
 417 }
 418
 419 void PerInstructionStats::push(const BenchmarkMeasure &BM) {
 420   if (Key.empty())
 421     Key = BM.Key;
 422   assert(Key == BM.Key);
 423   ++NumValues;
 424   SumValues += BM.PerInstructionValue;
 425   MaxValue = std::max(MaxValue, BM.PerInstructionValue);
 426   MinValue = std::min(MinValue, BM.PerInstructionValue);
 427 }
 428
 429 } // namespace exegesis
 430 } // namespace llvm