tools/llvm-exegesis/lib/BenchmarkResult.cpp

   1 //===-- BenchmarkResult.cpp -------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "BenchmarkResult.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/StringRef.h"
  13 #include "llvm/ObjectYAML/YAML.h"
  14 #include "llvm/Support/FileOutputBuffer.h"
  15 #include "llvm/Support/FileSystem.h"
  16 #include "llvm/Support/Format.h"
  17 #include "llvm/Support/raw_ostream.h"
  18
  19 static constexpr const char kIntegerFormat[] = "i_0x%" PRId64 "x";
  20 static constexpr const char kDoubleFormat[] = "f_%la";
  21
  22 static void serialize(const exegesis::BenchmarkResultContext &Context,
  23                       const llvm::MCOperand &MCOperand, llvm::raw_ostream &OS) {
  24   if (MCOperand.isReg()) {
  25     OS << Context.getRegName(MCOperand.getReg());
  26   } else if (MCOperand.isImm()) {
  27     OS << llvm::format(kIntegerFormat, MCOperand.getImm());
  28   } else if (MCOperand.isFPImm()) {
  29     OS << llvm::format(kDoubleFormat, MCOperand.getFPImm());
  30   } else {
  31     OS << "INVALID";
  32   }
  33 }
  34
  35 static void serialize(const exegesis::BenchmarkResultContext &Context,
  36                       const llvm::MCInst &MCInst, llvm::raw_ostream &OS) {
  37   OS << Context.getInstrName(MCInst.getOpcode());
  38   for (const auto &Op : MCInst) {
  39     OS << ' ';
  40     serialize(Context, Op, OS);
  41   }
  42 }
  43
  44 static llvm::MCOperand
  45 deserialize(const exegesis::BenchmarkResultContext &Context,
  46             llvm::StringRef String) {
  47   assert(!String.empty());
  48   int64_t IntValue = 0;
  49   double DoubleValue = 0;
  50   if (sscanf(String.data(), kIntegerFormat, &IntValue) == 1)
  51     return llvm::MCOperand::createImm(IntValue);
  52   if (sscanf(String.data(), kDoubleFormat, &DoubleValue) == 1)
  53     return llvm::MCOperand::createFPImm(DoubleValue);
  54   if (unsigned RegNo = Context.getRegNo(String)) // Returns 0 if invalid.
  55     return llvm::MCOperand::createReg(RegNo);
  56   return {};
  57 }
  58
  59 static llvm::StringRef
  60 deserialize(const exegesis::BenchmarkResultContext &Context,
  61             llvm::StringRef String, llvm::MCInst &Value) {
  62   llvm::SmallVector<llvm::StringRef, 8> Pieces;
  63   String.split(Pieces, " ", /* MaxSplit */ -1, /* KeepEmpty */ false);
  64   if (Pieces.empty())
  65     return "Invalid Instruction";
  66   bool ProcessOpcode = true;
  67   for (llvm::StringRef Piece : Pieces) {
  68     if (ProcessOpcode) {
  69       ProcessOpcode = false;
  70       Value.setOpcode(Context.getInstrOpcode(Piece));
  71       if (Value.getOpcode() == 0)
  72         return "Unknown Opcode Name";
  73     } else {
  74       Value.addOperand(deserialize(Context, Piece));
  75     }
  76   }
  77   return {};
  78 }
  79
  80 // YAML IO requires a mutable pointer to Context but we guarantee to not
  81 // modify it.
  82 static void *getUntypedContext(const exegesis::BenchmarkResultContext &Ctx) {
  83   return const_cast<exegesis::BenchmarkResultContext *>(&Ctx);
  84 }
  85
  86 static const exegesis::BenchmarkResultContext &getTypedContext(void *Ctx) {
  87   assert(Ctx);
  88   return *static_cast<const exegesis::BenchmarkResultContext *>(Ctx);
  89 }
  90
  91 // Defining YAML traits for IO.
  92 namespace llvm {
  93 namespace yaml {
  94
  95 // std::vector<llvm::MCInst> will be rendered as a list.
  96 template <> struct SequenceElementTraits<llvm::MCInst> {
  97   static const bool flow = false;
  98 };
  99
 100 template <> struct ScalarTraits<llvm::MCInst> {
 101
 102   static void output(const llvm::MCInst &Value, void *Ctx,
 103                      llvm::raw_ostream &Out) {
 104     serialize(getTypedContext(Ctx), Value, Out);
 105   }
 106
 107   static StringRef input(StringRef Scalar, void *Ctx, llvm::MCInst &Value) {
 108     return deserialize(getTypedContext(Ctx), Scalar, Value);
 109   }
 110
 111   static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 112
 113   static const bool flow = true;
 114 };
 115
 116 // std::vector<exegesis::Measure> will be rendered as a list.
 117 template <> struct SequenceElementTraits<exegesis::BenchmarkMeasure> {
 118   static const bool flow = false;
 119 };
 120
 121 // exegesis::Measure is rendererd as a flow instead of a list.
 122 // e.g. { "key": "the key", "value": 0123 }
 123 template <> struct MappingTraits<exegesis::BenchmarkMeasure> {
 124   static void mapping(IO &Io, exegesis::BenchmarkMeasure &Obj) {
 125     Io.mapRequired("key", Obj.Key);
 126     Io.mapRequired("value", Obj.Value);
 127     Io.mapOptional("debug_string", Obj.DebugString);
 128   }
 129   static const bool flow = true;
 130 };
 131
 132 template <>
 133 struct ScalarEnumerationTraits<exegesis::InstructionBenchmark::ModeE> {
 134   static void enumeration(IO &Io,
 135                           exegesis::InstructionBenchmark::ModeE &Value) {
 136     Io.enumCase(Value, "", exegesis::InstructionBenchmark::Unknown);
 137     Io.enumCase(Value, "latency", exegesis::InstructionBenchmark::Latency);
 138     Io.enumCase(Value, "uops", exegesis::InstructionBenchmark::Uops);
 139   }
 140 };
 141
 142 template <> struct MappingTraits<exegesis::InstructionBenchmarkKey> {
 143   static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj) {
 144     Io.mapRequired("instructions", Obj.Instructions);
 145     Io.mapOptional("config", Obj.Config);
 146   }
 147 };
 148
 149 template <> struct MappingTraits<exegesis::InstructionBenchmark> {
 150   class NormalizedBinary {
 151   public:
 152     NormalizedBinary(IO &io) {}
 153     NormalizedBinary(IO &, std::vector<uint8_t> &Data) : Binary(Data) {}
 154     std::vector<uint8_t> denormalize(IO &) {
 155       std::vector<uint8_t> Data;
 156       std::string Str;
 157       raw_string_ostream OSS(Str);
 158       Binary.writeAsBinary(OSS);
 159       OSS.flush();
 160       Data.assign(Str.begin(), Str.end());
 161       return Data;
 162     }
 163
 164     BinaryRef Binary;
 165   };
 166
 167   static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj) {
 168     Io.mapRequired("mode", Obj.Mode);
 169     Io.mapRequired("key", Obj.Key);
 170     Io.mapRequired("cpu_name", Obj.CpuName);
 171     Io.mapRequired("llvm_triple", Obj.LLVMTriple);
 172     Io.mapRequired("num_repetitions", Obj.NumRepetitions);
 173     Io.mapRequired("measurements", Obj.Measurements);
 174     Io.mapRequired("error", Obj.Error);
 175     Io.mapOptional("info", Obj.Info);
 176     // AssembledSnippet
 177     MappingNormalization<NormalizedBinary, std::vector<uint8_t>> BinaryString(
 178         Io, Obj.AssembledSnippet);
 179     Io.mapOptional("assembled_snippet", BinaryString->Binary);
 180   }
 181 };
 182
 183 } // namespace yaml
 184 } // namespace llvm
 185
 186 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(exegesis::InstructionBenchmark)
 187
 188 namespace exegesis {
 189
 190 void BenchmarkResultContext::addRegEntry(unsigned RegNo, llvm::StringRef Name) {
 191   assert(RegNoToName.find(RegNo) == RegNoToName.end());
 192   assert(RegNameToNo.find(Name) == RegNameToNo.end());
 193   RegNoToName[RegNo] = Name;
 194   RegNameToNo[Name] = RegNo;
 195 }
 196
 197 llvm::StringRef BenchmarkResultContext::getRegName(unsigned RegNo) const {
 198   const auto Itr = RegNoToName.find(RegNo);
 199   if (Itr != RegNoToName.end())
 200     return Itr->second;
 201   return {};
 202 }
 203
 204 unsigned BenchmarkResultContext::getRegNo(llvm::StringRef Name) const {
 205   const auto Itr = RegNameToNo.find(Name);
 206   if (Itr != RegNameToNo.end())
 207     return Itr->second;
 208   return 0;
 209 }
 210
 211 void BenchmarkResultContext::addInstrEntry(unsigned Opcode,
 212                                            llvm::StringRef Name) {
 213   assert(InstrOpcodeToName.find(Opcode) == InstrOpcodeToName.end());
 214   assert(InstrNameToOpcode.find(Name) == InstrNameToOpcode.end());
 215   InstrOpcodeToName[Opcode] = Name;
 216   InstrNameToOpcode[Name] = Opcode;
 217 }
 218
 219 llvm::StringRef BenchmarkResultContext::getInstrName(unsigned Opcode) const {
 220   const auto Itr = InstrOpcodeToName.find(Opcode);
 221   if (Itr != InstrOpcodeToName.end())
 222     return Itr->second;
 223   return {};
 224 }
 225
 226 unsigned BenchmarkResultContext::getInstrOpcode(llvm::StringRef Name) const {
 227   const auto Itr = InstrNameToOpcode.find(Name);
 228   if (Itr != InstrNameToOpcode.end())
 229     return Itr->second;
 230   return 0;
 231 }
 232
 233 template <typename ObjectOrList>
 234 static llvm::Expected<ObjectOrList>
 235 readYamlCommon(const BenchmarkResultContext &Context,
 236                llvm::StringRef Filename) {
 237   if (auto ExpectedMemoryBuffer =
 238           llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename))) {
 239     std::unique_ptr<llvm::MemoryBuffer> MemoryBuffer =
 240         std::move(ExpectedMemoryBuffer.get());
 241     llvm::yaml::Input Yin(*MemoryBuffer, getUntypedContext(Context));
 242     ObjectOrList Benchmark;
 243     Yin >> Benchmark;
 244     return Benchmark;
 245   } else {
 246     return ExpectedMemoryBuffer.takeError();
 247   }
 248 }
 249
 250 llvm::Expected<InstructionBenchmark>
 251 InstructionBenchmark::readYaml(const BenchmarkResultContext &Context,
 252                                llvm::StringRef Filename) {
 253   return readYamlCommon<InstructionBenchmark>(Context, Filename);
 254 }
 255
 256 llvm::Expected<std::vector<InstructionBenchmark>>
 257 InstructionBenchmark::readYamls(const BenchmarkResultContext &Context,
 258                                 llvm::StringRef Filename) {
 259   return readYamlCommon<std::vector<InstructionBenchmark>>(Context, Filename);
 260 }
 261
 262 void InstructionBenchmark::writeYamlTo(const BenchmarkResultContext &Context,
 263                                        llvm::raw_ostream &OS) {
 264   llvm::yaml::Output Yout(OS, getUntypedContext(Context));
 265   Yout << *this;
 266 }
 267
 268 void InstructionBenchmark::readYamlFrom(const BenchmarkResultContext &Context,
 269                                         llvm::StringRef InputContent) {
 270   llvm::yaml::Input Yin(InputContent, getUntypedContext(Context));
 271   Yin >> *this;
 272 }
 273
 274 llvm::Error
 275 InstructionBenchmark::writeYaml(const BenchmarkResultContext &Context,
 276                                 const llvm::StringRef Filename) {
 277   if (Filename == "-") {
 278     writeYamlTo(Context, llvm::outs());
 279   } else {
 280     int ResultFD = 0;
 281     if (auto E = llvm::errorCodeToError(
 282             openFileForWrite(Filename, ResultFD, llvm::sys::fs::CD_CreateAlways,
 283                              llvm::sys::fs::F_Text))) {
 284       return E;
 285     }
 286     llvm::raw_fd_ostream Ostr(ResultFD, true /*shouldClose*/);
 287     writeYamlTo(Context, Ostr);
 288   }
 289   return llvm::Error::success();
 290 }
 291
 292 void BenchmarkMeasureStats::push(const BenchmarkMeasure &BM) {
 293   if (Key.empty())
 294     Key = BM.Key;
 295   assert(Key == BM.Key);
 296   ++NumValues;
 297   SumValues += BM.Value;
 298   MaxValue = std::max(MaxValue, BM.Value);
 299   MinValue = std::min(MinValue, BM.Value);
 300 }
 301
 302 } // namespace exegesis