[llvm-exegesis] Serializes registers initial values.

[gchatelet]

Summary

Adds the registers initial values to the YAML output of llvm-exegesis.

[courbet]

tools/llvm-exegesis/lib/BenchmarkResult.cpp

217

please add a comment

tools/llvm-exegesis/lib/BenchmarkResult.h

19

BenchmarkCode.h

[gchatelet]

• Address comments.

[gchatelet]

• Address comments.
• Also add lit tests

test/tools/llvm-exegesis/X86/latency-by-opcode-name.s

 # RUN: llvm-exegesis -mode=latency -opcode-name=ADD32rr | FileCheck %s
 
 CHECK:      ---
-CHECK-NEXT: mode:            latency
+CHECK-NEXT: mode: latency
 CHECK-NEXT: key:
 CHECK-NEXT:   instructions:
 CHECK-NEXT:     ADD32rr
+CHECK-NEXT: config: ''
+CHECK-NEXT: register_initial_values:
+CHECK-DAG: - '[[REG1:[A-Z0-9]+]]=0x0'
 CHECK-LAST: ...

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 "BenchmarkCode.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 InstructionBenchmarkKey {
   // The LLVM opcode name.
   std::vector<llvm::MCInst> Instructions;
+  // The initial values of the registers.
+  std::vector<RegisterValue> RegisterInitialValues;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
 };
 
 struct BenchmarkMeasure {
   std::string Key;
   double Value;

tools/llvm-exegesis/lib/BenchmarkResult.cpp

for (llvm::StringRef Piece : Pieces) {
       else
         Value.addOperand(deserializeMCOperand(Piece));
       ProcessOpcode = false;
     }
   }
 
   std::string &getLastError() { return ErrorStream.str(); }
 
+  llvm::raw_string_ostream &getErrorStream() { return ErrorStream; }
+
+  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;
+  }
+
+  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;
+  }
+
 private:
   void serializeMCOperand(const llvm::MCOperand &MCOperand,
                           llvm::raw_ostream &OS) {
     if (MCOperand.isReg()) {
       OS << getRegName(MCOperand.getReg());
     } else if (MCOperand.isImm()) {
       OS << llvm::format(kIntegerFormat, MCOperand.getImm());
     } else if (MCOperand.isFPImm()) {
if (sscanf(String.data(), kDoubleFormat, &DoubleValue) == 1)
       return llvm::MCOperand::createFPImm(DoubleValue);
     if (unsigned RegNo = getRegNo(String))
       return llvm::MCOperand::createReg(RegNo);
     if (String != kInvalidOperand)
       ErrorStream << "Unknown Operand: '" << String << "'";
     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;
-  }
-
   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;
   }
 
   const exegesis::LLVMState *State;
   std::string LastError;
   llvm::raw_string_ostream ErrorStream;
 };
 
 // Defining YAML traits for IO.
 namespace llvm {
 namespace yaml {
 
+static YamlContext &getTypedContext(void *Ctx) {
+  return *reinterpret_cast<YamlContext *>(Ctx);
+}
+
 // 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) {
-    reinterpret_cast<YamlContext *>(Ctx)->serializeMCInst(Value, Out);
+    getTypedContext(Ctx).serializeMCInst(Value, Out);
   }
 
   static StringRef input(StringRef Scalar, void *Ctx, llvm::MCInst &Value) {
-    YamlContext &Context = *reinterpret_cast<YamlContext *>(Ctx);
+    YamlContext &Context = getTypedContext(Ctx);
     Context.deserializeMCInst(Scalar, Value);
     return Context.getLastError();
   }
 
+  // By default strings are quoted only when necessary.
+  // We force the use of single quotes for uniformity.
   static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 
   static const bool flow = true;
 };
 
 // std::vector<exegesis::Measure> will be rendered as a list.
 template <> struct SequenceElementTraits<exegesis::BenchmarkMeasure> {
   static const bool flow = false;
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);
   }
 };
 
+// std::vector<exegesis::RegisterValue> will be rendered as a list.
+template <> struct SequenceElementTraits<exegesis::RegisterValue> {
+  static const bool flow = false;
+};
+
+template <> struct ScalarTraits<exegesis::RegisterValue> {
+  static constexpr const unsigned kRadix = 16;
+  static constexpr const bool kSigned = false;
+
+  static void output(const exegesis::RegisterValue &RV, void *Ctx,
+                     llvm::raw_ostream &Out) {
+    YamlContext &Context = getTypedContext(Ctx);
+    Out << Context.getRegName(RV.Register) << "=0x"
+        << RV.Value.toString(kRadix, kSigned);
+  }
+
+  static StringRef input(StringRef String, void *Ctx,
+                         exegesis::RegisterValue &RV) {
+    llvm::SmallVector<llvm::StringRef, 2> Pieces;
+    String.split(Pieces, "=0x", /* MaxSplit */ -1,
+                 /* KeepEmpty */ false);
+    YamlContext &Context = getTypedContext(Ctx);
+    if (Pieces.size() == 2) {
+      RV.Register = Context.getRegNo(Pieces[0]);
+      const unsigned BitsNeeded = llvm::APInt::getBitsNeeded(Pieces[1], kRadix);
+      RV.Value = llvm::APInt(BitsNeeded, Pieces[1], kRadix);
+    } else {
+      Context.getErrorStream()
+          << "Unknown initial register value: '" << String << "'";
+    }
+    return Context.getLastError();
+  }
+
+  static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
+
+  static const bool flow = true;
+};
+
 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);
+    Io.mapRequired("register_initial_values", Obj.RegisterInitialValues);
   }
 };
 
 template <>
 struct MappingContextTraits<exegesis::InstructionBenchmark, YamlContext> {
-  class NormalizedBinary {
-  public:
+  struct NormalizedBinary {
     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();

tools/llvm-exegesis/lib/BenchmarkRunner.cpp

BenchmarkRunner::runConfiguration(const BenchmarkCode &BC,
   InstrBenchmark.LLVMTriple =
       State.getTargetMachine().getTargetTriple().normalize();
   InstrBenchmark.NumRepetitions = NumRepetitions;
   InstrBenchmark.Info = BC.Info;
 
   const std::vector<llvm::MCInst> &Instructions = BC.Instructions;
 
   InstrBenchmark.Key.Instructions = Instructions;
+  InstrBenchmark.Key.RegisterInitialValues = BC.RegisterInitialValues;
 
   // Assemble at least kMinInstructionsForSnippet instructions by repeating the
   // snippet for debug/analysis. This is so that the user clearly understands
   // that the inside instructions are repeated.
   constexpr const int kMinInstructionsForSnippet = 16;
   {
     auto ObjectFilePath = writeObjectFile(
         BC, GenerateInstructions(BC, kMinInstructionsForSnippet));

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

TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   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.Key.RegisterInitialValues = {
+      RegisterValue{llvm::X86::AL, llvm::APInt(8, "-1", 10)},
+      RegisterValue{llvm::X86::AH, llvm::APInt(8, "123", 10)}};
   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";