[llvm-exegesis][NFC] Rewrite of the YAML serialization.

[gchatelet]

Summary

This is a NFC in preparation of exporting the initial registers as part of the YAML dump

[gchatelet]

• Add missing Yin.setCurrentDocument()

[gchatelet]

• Add missing Yin.setCurrentDocument()
• Fix typo.

[courbet]

tools/llvm-exegesis/lib/BenchmarkResult.cpp

241 ↗

(On Diff #166817)

Let's add a second if (Context.error())

[gchatelet]

• Make YamlContext return an Error.

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

 /// Defines classes to represent measurements and serialize/deserialize them to
 //  Yaml.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H
 
+#include "LlvmState.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <limits>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 namespace exegesis {
 
-struct BenchmarkResultContext; // Forward declaration.
-
 struct InstructionBenchmarkKey {
   // The LLVM opcode name.
   std::vector<llvm::MCInst> Instructions;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
 };
 
struct InstructionBenchmark {
   // Note that measurements are per instruction.
   std::vector<BenchmarkMeasure> Measurements;
   std::string Error;
   std::string Info;
   std::vector<uint8_t> AssembledSnippet;
 
   // Read functions.
   static llvm::Expected<InstructionBenchmark>
-  readYaml(const BenchmarkResultContext &Context, llvm::StringRef Filename);
+  readYaml(const LLVMState &State, llvm::StringRef Filename);
 
   static llvm::Expected<std::vector<InstructionBenchmark>>
-  readYamls(const BenchmarkResultContext &Context, llvm::StringRef Filename);
+  readYamls(const LLVMState &State, llvm::StringRef Filename);
 
-  void readYamlFrom(const BenchmarkResultContext &Context,
-                    llvm::StringRef InputContent);
+  void readYamlFrom(const LLVMState &State, llvm::StringRef InputContent);
 
   // Write functions, non-const because of YAML traits.
-  void writeYamlTo(const BenchmarkResultContext &Context, llvm::raw_ostream &S);
+  void writeYamlTo(const LLVMState &State, llvm::raw_ostream &S);
 
-  llvm::Error writeYaml(const BenchmarkResultContext &Context,
-                        const llvm::StringRef Filename);
+  llvm::Error writeYaml(const LLVMState &State, const llvm::StringRef Filename);
 };
 
 //------------------------------------------------------------------------------
 // Utilities to work with Benchmark measures.
 
 // A class that measures stats over benchmark measures.
 class BenchmarkMeasureStats {
 public:

 private:
   std::string Key;
   double SumValues = 0.0;
   int NumValues = 0;
   double MaxValue = std::numeric_limits<double>::min();
   double MinValue = std::numeric_limits<double>::max();
 };
 
-// This context is used when de/serializing InstructionBenchmark to guarantee
-// that Registers and Instructions are human readable and preserved accross
-// different versions of LLVM.
-struct BenchmarkResultContext {
-  BenchmarkResultContext() = default;
-  BenchmarkResultContext(BenchmarkResultContext &&) = default;
-  BenchmarkResultContext &operator=(BenchmarkResultContext &&) = default;
-  BenchmarkResultContext(const BenchmarkResultContext &) = delete;
-  BenchmarkResultContext &operator=(const BenchmarkResultContext &) = delete;
-
-  // Populate Registers and Instruction mapping.
-  void addRegEntry(unsigned RegNo, llvm::StringRef Name);
-  void addInstrEntry(unsigned Opcode, llvm::StringRef Name);
-
-  // Register accessors.
-  llvm::StringRef getRegName(unsigned RegNo) const;
-  unsigned getRegNo(llvm::StringRef Name) const; // 0 is not found.
-
-  // Instruction accessors.
-  llvm::StringRef getInstrName(unsigned Opcode) const;
-  unsigned getInstrOpcode(llvm::StringRef Name) const; // 0 is not found.
-
-private:
-  // Ideally we would like to use MCRegisterInfo and MCInstrInfo but doing so
-  // would make testing harder, instead we create a mapping that we can easily
-  // populate.
-  std::unordered_map<unsigned, llvm::StringRef> InstrOpcodeToName;
-  std::unordered_map<unsigned, llvm::StringRef> RegNoToName;
-  llvm::StringMap<unsigned> InstrNameToOpcode;
-  llvm::StringMap<unsigned> RegNameToNo;
-};
-
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H

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

 //===-- BenchmarkResult.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BenchmarkResult.h"
+#include "BenchmarkRunner.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 static constexpr const char kIntegerFormat[] = "i_0x%" PRId64 "x";
 static constexpr const char kDoubleFormat[] = "f_%la";
+static constexpr const char kInvalidOperand[] = "INVALID";
 
-static void serialize(const exegesis::BenchmarkResultContext &Context,
-                      const llvm::MCOperand &MCOperand, llvm::raw_ostream &OS) {
+// A mutable struct holding an LLVMState that can be passed through the
+// serialization process to encode/decode registers and instructions.
+struct YamlContext {
+  YamlContext(const exegesis::LLVMState &State)
+      : State(&State), ErrorStream(LastError) {}
+
+  void serializeMCInst(const llvm::MCInst &MCInst, llvm::raw_ostream &OS) {
+    OS << getInstrName(MCInst.getOpcode());
+    for (const auto &Op : MCInst) {
+      OS << ' ';
+      serializeMCOperand(Op, OS);
+    }
+  }
+
+  void deserializeMCInst(llvm::StringRef String, llvm::MCInst &Value) {
+    llvm::SmallVector<llvm::StringRef, 8> Pieces;
+    String.split(Pieces, " ", /* MaxSplit */ -1, /* KeepEmpty */ false);
+    if (Pieces.empty()) {
+      ErrorStream << "Unknown Instruction: '" << String << "'";
+      return;
+    }
+    bool ProcessOpcode = true;
+    for (llvm::StringRef Piece : Pieces) {
+      if (ProcessOpcode)
+        Value.setOpcode(getInstrOpcode(Piece));
+      else
+        Value.addOperand(deserializeMCOperand(Piece));
+      ProcessOpcode = false;
+    }
+  }
+
+  std::string &getLastError() { return ErrorStream.str(); }
+
+private:
+  void serializeMCOperand(const llvm::MCOperand &MCOperand,
+                          llvm::raw_ostream &OS) {
     if (MCOperand.isReg()) {
-    OS << Context.getRegName(MCOperand.getReg());
+      OS << getRegName(MCOperand.getReg());
     } else if (MCOperand.isImm()) {
       OS << llvm::format(kIntegerFormat, MCOperand.getImm());
     } else if (MCOperand.isFPImm()) {
       OS << llvm::format(kDoubleFormat, MCOperand.getFPImm());
     } else {
-    OS << "INVALID";
+      OS << kInvalidOperand;
     }
   }
 
-static void serialize(const exegesis::BenchmarkResultContext &Context,
-                      const llvm::MCInst &MCInst, llvm::raw_ostream &OS) {
-  OS << Context.getInstrName(MCInst.getOpcode());
-  for (const auto &Op : MCInst) {
-    OS << ' ';
-    serialize(Context, Op, OS);
-  }
-}
-
-static llvm::MCOperand
-deserialize(const exegesis::BenchmarkResultContext &Context,
-            llvm::StringRef String) {
+  llvm::MCOperand deserializeMCOperand(llvm::StringRef String) {
     assert(!String.empty());
     int64_t IntValue = 0;
     double DoubleValue = 0;
     if (sscanf(String.data(), kIntegerFormat, &IntValue) == 1)
       return llvm::MCOperand::createImm(IntValue);
     if (sscanf(String.data(), kDoubleFormat, &DoubleValue) == 1)
       return llvm::MCOperand::createFPImm(DoubleValue);
-  if (unsigned RegNo = Context.getRegNo(String)) // Returns 0 if invalid.
+    if (unsigned RegNo = getRegNo(String))
       return llvm::MCOperand::createReg(RegNo);
+    if (String != kInvalidOperand)
+      ErrorStream << "Unknown Operand: '" << String << "'";
     return {};
   }
 
-static llvm::StringRef
-deserialize(const exegesis::BenchmarkResultContext &Context,
-            llvm::StringRef String, llvm::MCInst &Value) {
-  llvm::SmallVector<llvm::StringRef, 8> Pieces;
-  String.split(Pieces, " ", /* MaxSplit */ -1, /* KeepEmpty */ false);
-  if (Pieces.empty())
-    return "Invalid Instruction";
-  bool ProcessOpcode = true;
-  for (llvm::StringRef Piece : Pieces) {
-    if (ProcessOpcode) {
-      ProcessOpcode = false;
-      Value.setOpcode(Context.getInstrOpcode(Piece));
-      if (Value.getOpcode() == 0)
-        return "Unknown Opcode Name";
-    } else {
-      Value.addOperand(deserialize(Context, Piece));
-    }
-  }
-  return {};
+  llvm::StringRef getRegName(unsigned RegNo) {
+    const llvm::StringRef RegName = State->getRegInfo().getName(RegNo);
+    if (RegName.empty())
+      ErrorStream << "No register with enum value" << RegNo;
+    return RegName;
+  }
+
+  llvm::StringRef getInstrName(unsigned InstrNo) {
+    const llvm::StringRef InstrName = State->getInstrInfo().getName(InstrNo);
+    if (InstrName.empty())
+      ErrorStream << "No opcode with enum value" << InstrNo;
+    return InstrName;
+  }
+
+  unsigned getRegNo(llvm::StringRef RegName) {
+    const llvm::MCRegisterInfo &RegInfo = State->getRegInfo();
+    for (unsigned E = RegInfo.getNumRegs(), I = 0; I < E; ++I)
+      if (RegInfo.getName(I) == RegName)
+        return I;
+    ErrorStream << "No register with name " << RegName;
+    return 0;
   }
 
-// YAML IO requires a mutable pointer to Context but we guarantee to not
-// modify it.
-static void *getUntypedContext(const exegesis::BenchmarkResultContext &Ctx) {
-  return const_cast<exegesis::BenchmarkResultContext *>(&Ctx);
+  unsigned getInstrOpcode(llvm::StringRef InstrName) {
+    const llvm::MCInstrInfo &InstrInfo = State->getInstrInfo();
+    for (unsigned E = InstrInfo.getNumOpcodes(), I = 0; I < E; ++I)
+      if (InstrInfo.getName(I) == InstrName)
+        return I;
+    ErrorStream << "No opcode with name " << InstrName;
+    return 0;
   }
 
-static const exegesis::BenchmarkResultContext &getTypedContext(void *Ctx) {
-  assert(Ctx);
-  return *static_cast<const exegesis::BenchmarkResultContext *>(Ctx);
-}
+  const exegesis::LLVMState *State;
+  std::string LastError;
+  llvm::raw_string_ostream ErrorStream;
+};
 
 // Defining YAML traits for IO.
 namespace llvm {
 namespace yaml {
 
 // std::vector<llvm::MCInst> will be rendered as a list.
 template <> struct SequenceElementTraits<llvm::MCInst> {
   static const bool flow = false;
 };
 
 template <> struct ScalarTraits<llvm::MCInst> {
 
   static void output(const llvm::MCInst &Value, void *Ctx,
                      llvm::raw_ostream &Out) {
-    serialize(getTypedContext(Ctx), Value, Out);
+    reinterpret_cast<YamlContext *>(Ctx)->serializeMCInst(Value, Out);
   }
 
   static StringRef input(StringRef Scalar, void *Ctx, llvm::MCInst &Value) {
-    return deserialize(getTypedContext(Ctx), Scalar, Value);
+    YamlContext &Context = *reinterpret_cast<YamlContext *>(Ctx);
+    Context.deserializeMCInst(Scalar, Value);
+    return Context.getLastError();
   }
 
   static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 
   static const bool flow = true;
 };
 
 // std::vector<exegesis::Measure> will be rendered as a list.
struct ScalarEnumerationTraits<exegesis::InstructionBenchmark::ModeE> {
   static void enumeration(IO &Io,
                           exegesis::InstructionBenchmark::ModeE &Value) {
     Io.enumCase(Value, "", exegesis::InstructionBenchmark::Unknown);
     Io.enumCase(Value, "latency", exegesis::InstructionBenchmark::Latency);
     Io.enumCase(Value, "uops", exegesis::InstructionBenchmark::Uops);
   }
 };
 
-template <> struct MappingTraits<exegesis::InstructionBenchmarkKey> {
-  static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj) {
+template <>
+struct MappingContextTraits<exegesis::InstructionBenchmarkKey, YamlContext> {
+  static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj,
+                      YamlContext &Context) {
+    Io.setContext(&Context);
     Io.mapRequired("instructions", Obj.Instructions);
     Io.mapOptional("config", Obj.Config);
   }
 };
 
-template <> struct MappingTraits<exegesis::InstructionBenchmark> {
+template <>
+struct MappingContextTraits<exegesis::InstructionBenchmark, YamlContext> {
   class NormalizedBinary {
   public:
     NormalizedBinary(IO &io) {}
     NormalizedBinary(IO &, std::vector<uint8_t> &Data) : Binary(Data) {}
     std::vector<uint8_t> denormalize(IO &) {
       std::vector<uint8_t> Data;
       std::string Str;
       raw_string_ostream OSS(Str);
       Binary.writeAsBinary(OSS);
       OSS.flush();
       Data.assign(Str.begin(), Str.end());
       return Data;
     }
 
     BinaryRef Binary;
   };
 
-  static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj) {
+  static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj,
+                      YamlContext &Context) {
     Io.mapRequired("mode", Obj.Mode);
-    Io.mapRequired("key", Obj.Key);
+    Io.mapRequired("key", Obj.Key, Context);
     Io.mapRequired("cpu_name", Obj.CpuName);
     Io.mapRequired("llvm_triple", Obj.LLVMTriple);
     Io.mapRequired("num_repetitions", Obj.NumRepetitions);
     Io.mapRequired("measurements", Obj.Measurements);
     Io.mapRequired("error", Obj.Error);
     Io.mapOptional("info", Obj.Info);
     // AssembledSnippet
     MappingNormalization<NormalizedBinary, std::vector<uint8_t>> BinaryString(
         Io, Obj.AssembledSnippet);
     Io.mapOptional("assembled_snippet", BinaryString->Binary);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
-LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(exegesis::InstructionBenchmark)
-
 namespace exegesis {
 
-void BenchmarkResultContext::addRegEntry(unsigned RegNo, llvm::StringRef Name) {
-  assert(RegNoToName.find(RegNo) == RegNoToName.end());
-  assert(RegNameToNo.find(Name) == RegNameToNo.end());
-  RegNoToName[RegNo] = Name;
-  RegNameToNo[Name] = RegNo;
-}
-
-llvm::StringRef BenchmarkResultContext::getRegName(unsigned RegNo) const {
-  const auto Itr = RegNoToName.find(RegNo);
-  if (Itr != RegNoToName.end())
-    return Itr->second;
-  return {};
-}
-
-unsigned BenchmarkResultContext::getRegNo(llvm::StringRef Name) const {
-  const auto Itr = RegNameToNo.find(Name);
-  if (Itr != RegNameToNo.end())
-    return Itr->second;
-  return 0;
-}
-
-void BenchmarkResultContext::addInstrEntry(unsigned Opcode,
-                                           llvm::StringRef Name) {
-  assert(InstrOpcodeToName.find(Opcode) == InstrOpcodeToName.end());
-  assert(InstrNameToOpcode.find(Name) == InstrNameToOpcode.end());
-  InstrOpcodeToName[Opcode] = Name;
-  InstrNameToOpcode[Name] = Opcode;
-}
-
-llvm::StringRef BenchmarkResultContext::getInstrName(unsigned Opcode) const {
-  const auto Itr = InstrOpcodeToName.find(Opcode);
-  if (Itr != InstrOpcodeToName.end())
-    return Itr->second;
-  return {};
-}
-
-unsigned BenchmarkResultContext::getInstrOpcode(llvm::StringRef Name) const {
-  const auto Itr = InstrNameToOpcode.find(Name);
-  if (Itr != InstrNameToOpcode.end())
-    return Itr->second;
-  return 0;
-}
-
-template <typename ObjectOrList>
-static llvm::Expected<ObjectOrList>
-readYamlCommon(const BenchmarkResultContext &Context,
+llvm::Expected<InstructionBenchmark>
+InstructionBenchmark::readYaml(const LLVMState &State,
                                llvm::StringRef Filename) {
   if (auto ExpectedMemoryBuffer =
           llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename))) {
-    std::unique_ptr<llvm::MemoryBuffer> MemoryBuffer =
-        std::move(ExpectedMemoryBuffer.get());
-    llvm::yaml::Input Yin(*MemoryBuffer, getUntypedContext(Context));
-    ObjectOrList Benchmark;
-    Yin >> Benchmark;
+    llvm::yaml::Input Yin(*ExpectedMemoryBuffer.get());
+    YamlContext Context(State);
+    InstructionBenchmark Benchmark;
+    if (Yin.setCurrentDocument())
+      llvm::yaml::yamlize(Yin, Benchmark, /*unused*/ true, Context);
+    if (!Context.getLastError().empty())
+      return llvm::make_error<BenchmarkFailure>(Context.getLastError());
     return Benchmark;
   } else {
     return ExpectedMemoryBuffer.takeError();
   }
 }
 
-llvm::Expected<InstructionBenchmark>
-InstructionBenchmark::readYaml(const BenchmarkResultContext &Context,
-                               llvm::StringRef Filename) {
-  return readYamlCommon<InstructionBenchmark>(Context, Filename);
-}
-
 llvm::Expected<std::vector<InstructionBenchmark>>
-InstructionBenchmark::readYamls(const BenchmarkResultContext &Context,
+InstructionBenchmark::readYamls(const LLVMState &State,
                                 llvm::StringRef Filename) {
-  return readYamlCommon<std::vector<InstructionBenchmark>>(Context, Filename);
+  if (auto ExpectedMemoryBuffer =
+          llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename))) {
+    llvm::yaml::Input Yin(*ExpectedMemoryBuffer.get());
+    YamlContext Context(State);
+    std::vector<InstructionBenchmark> Benchmarks;
+    while (Yin.setCurrentDocument()) {
+      Benchmarks.emplace_back();
+      yamlize(Yin, Benchmarks.back(), /*unused*/ true, Context);
+      if (Yin.error())
+        return llvm::errorCodeToError(Yin.error());
+      if (!Context.getLastError().empty())
+        return llvm::make_error<BenchmarkFailure>(Context.getLastError());
+      Yin.nextDocument();
+    }
+    return Benchmarks;
+  } else {
+    return ExpectedMemoryBuffer.takeError();
+  }
 }
 
-void InstructionBenchmark::writeYamlTo(const BenchmarkResultContext &Context,
+void InstructionBenchmark::writeYamlTo(const LLVMState &State,
                                        llvm::raw_ostream &OS) {
-  llvm::yaml::Output Yout(OS, getUntypedContext(Context));
-  Yout << *this;
+  llvm::yaml::Output Yout(OS);
+  YamlContext Context(State);
+  llvm::yaml::yamlize(Yout, *this, /*unused*/ true, Context);
 }
 
-void InstructionBenchmark::readYamlFrom(const BenchmarkResultContext &Context,
+void InstructionBenchmark::readYamlFrom(const LLVMState &State,
                                         llvm::StringRef InputContent) {
-  llvm::yaml::Input Yin(InputContent, getUntypedContext(Context));
-  Yin >> *this;
+  llvm::yaml::Input Yin(InputContent);
+  YamlContext Context(State);
+  if (Yin.setCurrentDocument())
+    llvm::yaml::yamlize(Yin, *this, /*unused*/ true, Context);
 }
 
-llvm::Error
-InstructionBenchmark::writeYaml(const BenchmarkResultContext &Context,
+llvm::Error InstructionBenchmark::writeYaml(const LLVMState &State,
                                             const llvm::StringRef Filename) {
   if (Filename == "-") {
-    writeYamlTo(Context, llvm::outs());
+    writeYamlTo(State, llvm::outs());
   } else {
     int ResultFD = 0;
     if (auto E = llvm::errorCodeToError(
             openFileForWrite(Filename, ResultFD, llvm::sys::fs::CD_CreateAlways,
                              llvm::sys::fs::F_Text))) {
       return E;
     }
     llvm::raw_fd_ostream Ostr(ResultFD, true /*shouldClose*/);
-    writeYamlTo(Context, Ostr);
+    writeYamlTo(State, Ostr);
   }
   return llvm::Error::success();
 }
 
 void BenchmarkMeasureStats::push(const BenchmarkMeasure &BM) {
   if (Key.empty())
     Key = BM.Key;
   assert(Key == BM.Key);
   ++NumValues;
   SumValues += BM.Value;
   MaxValue = std::max(MaxValue, BM.Value);
   MinValue = std::min(MinValue, BM.Value);
 }
 
 } // namespace exegesis

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

if (OpcodeIndex > 0)
     return OpcodeIndex;
   // Resolve opcode name -> opcode.
   for (unsigned I = 0, E = MCInstrInfo.getNumOpcodes(); I < E; ++I)
     if (MCInstrInfo.getName(I) == OpcodeName)
       return I;
   llvm::report_fatal_error(llvm::Twine("unknown opcode ").concat(OpcodeName));
 }
 
-static BenchmarkResultContext
-getBenchmarkResultContext(const LLVMState &State) {
-  BenchmarkResultContext Ctx;
-
-  const llvm::MCInstrInfo &InstrInfo = State.getInstrInfo();
-  for (unsigned E = InstrInfo.getNumOpcodes(), I = 0; I < E; ++I)
-    Ctx.addInstrEntry(I, InstrInfo.getName(I).data());
-
-  const llvm::MCRegisterInfo &RegInfo = State.getRegInfo();
-  for (unsigned E = RegInfo.getNumRegs(), I = 0; I < E; ++I)
-    Ctx.addRegEntry(I, RegInfo.getName(I));
-
-  return Ctx;
-}
-
 // Generates code snippets for opcode `Opcode`.
 static llvm::Expected<std::vector<BenchmarkCode>>
 generateSnippets(const LLVMState &State, unsigned Opcode) {
   const std::unique_ptr<SnippetGenerator> Generator =
       State.getExegesisTarget().createSnippetGenerator(BenchmarkMode, State);
   if (!Generator)
     llvm::report_fatal_error("cannot create snippet generator");
 
#endif
 
   if (NumRepetitions == 0)
     llvm::report_fatal_error("--num-repetitions must be greater than zero");
 
   // Write to standard output if file is not set.
   if (BenchmarkFile.empty())
     BenchmarkFile = "-";
 
-  const BenchmarkResultContext Context = getBenchmarkResultContext(State);
-
   for (const BenchmarkCode &Conf : Configurations) {
     InstructionBenchmark Result =
         Runner->runConfiguration(Conf, NumRepetitions);
-    ExitOnErr(Result.writeYaml(Context, BenchmarkFile));
+    ExitOnErr(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>
 static void maybeRunAnalysis(const Analysis &Analyzer, const std::string &Name,
if (BenchmarkFile.empty())
     llvm::report_fatal_error("--benchmarks-file must be set.");
 
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
   llvm::InitializeNativeTargetDisassembler();
   // Read benchmarks.
   const LLVMState State;
   const std::vector<InstructionBenchmark> Points =
-      ExitOnErr(InstructionBenchmark::readYamls(
-          getBenchmarkResultContext(State), BenchmarkFile));
+      ExitOnErr(InstructionBenchmark::readYamls(State, BenchmarkFile));
   llvm::outs() << "Parsed " << Points.size() << " benchmark points\n";
   if (Points.empty()) {
     llvm::errs() << "no benchmarks to analyze\n";
     return;
   }
   // FIXME: Check that all points have the same triple/cpu.
   // FIXME: Merge points from several runs (latency and uops).
 

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

-//===-- BenchmarkResultTest.cpp ---------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "BenchmarkResult.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/YAMLTraits.h"
-#include "llvm/Support/raw_ostream.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-using ::testing::AllOf;
-using ::testing::Eq;
-using ::testing::get;
-using ::testing::Pointwise;
-using ::testing::Property;
-
-namespace exegesis {
-
-bool operator==(const BenchmarkMeasure &A, const BenchmarkMeasure &B) {
-  return std::tie(A.Key, A.Value) == std::tie(B.Key, B.Value);
-}
-
-static std::string Dump(const llvm::MCInst &McInst) {
-  std::string Buffer;
-  llvm::raw_string_ostream OS(Buffer);
-  McInst.print(OS);
-  return Buffer;
-}
-
-MATCHER(EqMCInst, "") {
-  const std::string Lhs = Dump(get<0>(arg));
-  const std::string Rhs = Dump(get<1>(arg));
-  if (Lhs != Rhs) {
-    *result_listener << Lhs << " <=> " << Rhs;
-    return false;
-  }
-  return true;
-}
-
-namespace {
-
-static constexpr const unsigned kInstrId = 5;
-static constexpr const char kInstrName[] = "Instruction5";
-static constexpr const unsigned kReg1Id = 1;
-static constexpr const char kReg1Name[] = "Reg1";
-static constexpr const unsigned kReg2Id = 2;
-static constexpr const char kReg2Name[] = "Reg2";
-
-TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
-  llvm::ExitOnError ExitOnErr;
-  BenchmarkResultContext Ctx;
-  Ctx.addInstrEntry(kInstrId, kInstrName);
-  Ctx.addRegEntry(kReg1Id, kReg1Name);
-  Ctx.addRegEntry(kReg2Id, kReg2Name);
-
-  InstructionBenchmark ToDisk;
-
-  ToDisk.Key.Instructions.push_back(llvm::MCInstBuilder(kInstrId)
-                                        .addReg(kReg1Id)
-                                        .addReg(kReg2Id)
-                                        .addImm(123)
-                                        .addFPImm(0.5));
-  ToDisk.Key.Config = "config";
-  ToDisk.Mode = InstructionBenchmark::Latency;
-  ToDisk.CpuName = "cpu_name";
-  ToDisk.LLVMTriple = "llvm_triple";
-  ToDisk.NumRepetitions = 1;
-  ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, "debug a"});
-  ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, ""});
-  ToDisk.Error = "error";
-  ToDisk.Info = "info";
-
-  llvm::SmallString<64> Filename;
-  std::error_code EC;
-  EC = llvm::sys::fs::createUniqueDirectory("BenchmarkResultTestDir", Filename);
-  ASSERT_FALSE(EC);
-  llvm::sys::path::append(Filename, "data.yaml");
-  ExitOnErr(ToDisk.writeYaml(Ctx, Filename));
-
-  {
-    // One-element version.
-    const auto FromDisk =
-        ExitOnErr(InstructionBenchmark::readYaml(Ctx, Filename));
-
-    EXPECT_THAT(FromDisk.Key.Instructions,
-                Pointwise(EqMCInst(), ToDisk.Key.Instructions));
-    EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
-    EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
-    EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
-    EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
-    EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
-    EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
-    EXPECT_THAT(FromDisk.Error, ToDisk.Error);
-    EXPECT_EQ(FromDisk.Info, ToDisk.Info);
-  }
-  {
-    // Vector version.
-    const auto FromDiskVector =
-        ExitOnErr(InstructionBenchmark::readYamls(Ctx, Filename));
-    ASSERT_EQ(FromDiskVector.size(), size_t{1});
-    const auto FromDisk = FromDiskVector[0];
-    EXPECT_THAT(FromDisk.Key.Instructions,
-                Pointwise(EqMCInst(), ToDisk.Key.Instructions));
-    EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
-    EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
-    EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
-    EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
-    EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
-    EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
-    EXPECT_THAT(FromDisk.Error, ToDisk.Error);
-    EXPECT_EQ(FromDisk.Info, ToDisk.Info);
-  }
-}
-
-TEST(BenchmarkResultTest, BenchmarkMeasureStats) {
-  BenchmarkMeasureStats Stats;
-  Stats.push(BenchmarkMeasure{"a", 0.5, "debug a"});
-  Stats.push(BenchmarkMeasure{"a", 1.5, "debug a"});
-  Stats.push(BenchmarkMeasure{"a", -1.0, "debug a"});
-  Stats.push(BenchmarkMeasure{"a", 0.0, "debug a"});
-  EXPECT_EQ(Stats.min(), -1.0);
-  EXPECT_EQ(Stats.max(), 1.5);
-  EXPECT_EQ(Stats.avg(), 0.25); // (0.5+1.5-1.0+0.0) / 4
-}
-} // namespace
-} // namespace exegesis

llvm/trunk/unittests/tools/llvm-exegesis/CMakeLists.txt

 include_directories(
   ${LLVM_MAIN_SRC_DIR}/tools/llvm-exegesis/lib
   )
 
 set(LLVM_LINK_COMPONENTS
   MC
   MCParser
   Object
   Support
   Symbolize
   )
 
 add_llvm_unittest(LLVMExegesisTests
-  BenchmarkResultTest.cpp
   BenchmarkRunnerTest.cpp
   ClusteringTest.cpp
   PerfHelperTest.cpp
   RegisterValueTest.cpp
   )
 target_link_libraries(LLVMExegesisTests PRIVATE LLVMExegesis)
 
 if(LLVM_TARGETS_TO_BUILD MATCHES "X86")
   add_subdirectory(X86)
 endif()
 if(LLVM_TARGETS_TO_BUILD MATCHES "ARM")
   add_subdirectory(ARM)
 endif()
 if(LLVM_TARGETS_TO_BUILD MATCHES "AArch64")
   add_subdirectory(AArch64)
 endif()

llvm/trunk/unittests/tools/llvm-exegesis/X86/BenchmarkResultTest.cpp

+//===-- BenchmarkResultTest.cpp ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "BenchmarkResult.h"
+#include "X86InstrInfo.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::AllOf;
+using ::testing::Eq;
+using ::testing::get;
+using ::testing::Pointwise;
+using ::testing::Property;
+
+namespace exegesis {
+
+bool operator==(const BenchmarkMeasure &A, const BenchmarkMeasure &B) {
+  return std::tie(A.Key, A.Value) == std::tie(B.Key, B.Value);
+}
+
+static std::string Dump(const llvm::MCInst &McInst) {
+  std::string Buffer;
+  llvm::raw_string_ostream OS(Buffer);
+  McInst.print(OS);
+  return Buffer;
+}
+
+MATCHER(EqMCInst, "") {
+  const std::string Lhs = Dump(get<0>(arg));
+  const std::string Rhs = Dump(get<1>(arg));
+  if (Lhs != Rhs) {
+    *result_listener << Lhs << " <=> " << Rhs;
+    return false;
+  }
+  return true;
+}
+
+namespace {
+
+TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
+  LLVMInitializeX86TargetInfo();
+  LLVMInitializeX86Target();
+  LLVMInitializeX86TargetMC();
+
+  // Read benchmarks.
+  const LLVMState State;
+
+  llvm::ExitOnError ExitOnErr;
+
+  InstructionBenchmark ToDisk;
+
+  ToDisk.Key.Instructions.push_back(llvm::MCInstBuilder(llvm::X86::XOR32rr)
+                                        .addReg(llvm::X86::AL)
+                                        .addReg(llvm::X86::AH)
+                                        .addImm(123)
+                                        .addFPImm(0.5));
+  ToDisk.Key.Config = "config";
+  ToDisk.Mode = InstructionBenchmark::Latency;
+  ToDisk.CpuName = "cpu_name";
+  ToDisk.LLVMTriple = "llvm_triple";
+  ToDisk.NumRepetitions = 1;
+  ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, "debug a"});
+  ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, ""});
+  ToDisk.Error = "error";
+  ToDisk.Info = "info";
+
+  llvm::SmallString<64> Filename;
+  std::error_code EC;
+  EC = llvm::sys::fs::createUniqueDirectory("BenchmarkResultTestDir", Filename);
+  ASSERT_FALSE(EC);
+  llvm::sys::path::append(Filename, "data.yaml");
+  llvm::errs() << Filename << "-------\n";
+  ExitOnErr(ToDisk.writeYaml(State, Filename));
+
+  {
+    // One-element version.
+    const auto FromDisk =
+        ExitOnErr(InstructionBenchmark::readYaml(State, Filename));
+
+    EXPECT_THAT(FromDisk.Key.Instructions,
+                Pointwise(EqMCInst(), ToDisk.Key.Instructions));
+    EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
+    EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
+    EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
+    EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
+    EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
+    EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
+    EXPECT_THAT(FromDisk.Error, ToDisk.Error);
+    EXPECT_EQ(FromDisk.Info, ToDisk.Info);
+  }
+  {
+    // Vector version.
+    const auto FromDiskVector =
+        ExitOnErr(InstructionBenchmark::readYamls(State, Filename));
+    ASSERT_EQ(FromDiskVector.size(), size_t{1});
+    const auto FromDisk = FromDiskVector[0];
+    EXPECT_THAT(FromDisk.Key.Instructions,
+                Pointwise(EqMCInst(), ToDisk.Key.Instructions));
+    EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
+    EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
+    EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
+    EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
+    EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
+    EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
+    EXPECT_THAT(FromDisk.Error, ToDisk.Error);
+    EXPECT_EQ(FromDisk.Info, ToDisk.Info);
+  }
+}
+
+TEST(BenchmarkResultTest, BenchmarkMeasureStats) {
+  BenchmarkMeasureStats Stats;
+  Stats.push(BenchmarkMeasure{"a", 0.5, "debug a"});
+  Stats.push(BenchmarkMeasure{"a", 1.5, "debug a"});
+  Stats.push(BenchmarkMeasure{"a", -1.0, "debug a"});
+  Stats.push(BenchmarkMeasure{"a", 0.0, "debug a"});
+  EXPECT_EQ(Stats.min(), -1.0);
+  EXPECT_EQ(Stats.max(), 1.5);
+  EXPECT_EQ(Stats.avg(), 0.25); // (0.5+1.5-1.0+0.0) / 4
+}
+} // namespace
+} // namespace exegesis

llvm/trunk/unittests/tools/llvm-exegesis/X86/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   Support
   Symbolize
   X86
   )
 
 add_llvm_unittest(LLVMExegesisX86Tests
   AssemblerTest.cpp
   AnalysisTest.cpp
+  BenchmarkResultTest.cpp
   SnippetGeneratorTest.cpp
   RegisterAliasingTest.cpp
   TargetTest.cpp
   )
 target_link_libraries(LLVMExegesisX86Tests PRIVATE
   LLVMExegesis
   LLVMExegesisX86)