[llvm-exegesis] Allow lists of BenchmarkResults to be parsed as std::vector<BenchmarkResult>.

[courbet]

Submitted as r332221

tools/llvm-exegesis/lib/BenchmarkResult.h

struct InstructionBenchmark {
   AsmTemplate AsmTmpl;
   std::string CpuName;
   std::string LLVMTriple;
   int NumRepetitions = 0;
   std::vector<BenchmarkMeasure> Measurements;
   std::string Error;
 
   static InstructionBenchmark readYamlOrDie(llvm::StringRef Filename);
+  static std::vector<InstructionBenchmark> readYamlsOrDie(llvm::StringRef Filename);
 
   // Unfortunately this function is non const because of YAML traits.
   void writeYamlOrDie(const llvm::StringRef Filename);
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H

tools/llvm-exegesis/lib/BenchmarkResult.cpp

static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj) {
     Io.mapRequired("measurements", Obj.Measurements);
     Io.mapRequired("error", Obj.Error);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
+LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(exegesis::InstructionBenchmark)
+
 namespace exegesis {
 
-InstructionBenchmark
-InstructionBenchmark::readYamlOrDie(llvm::StringRef Filename) {
+namespace {
+
+template <typename ObjectOrList>
+ObjectOrList readYamlOrDieCommon(llvm::StringRef Filename) {
   std::unique_ptr<llvm::MemoryBuffer> MemBuffer = llvm::cantFail(
       llvm::errorOrToExpected(llvm::MemoryBuffer::getFile(Filename)));
   llvm::yaml::Input Yin(*MemBuffer);
-  InstructionBenchmark Benchmark;
+  ObjectOrList Benchmark;
   Yin >> Benchmark;
   return Benchmark;
 }
 
+} // namespace
+
+InstructionBenchmark
+InstructionBenchmark::readYamlOrDie(llvm::StringRef Filename) {
+  return readYamlOrDieCommon<InstructionBenchmark>(Filename);
+}
+
+std::vector<InstructionBenchmark>
+InstructionBenchmark::readYamlsOrDie(llvm::StringRef Filename) {
+  return readYamlOrDieCommon<std::vector<InstructionBenchmark>>(Filename);
+}
+
 void InstructionBenchmark::writeYamlOrDie(const llvm::StringRef Filename) {
   if (Filename == "-") {
     llvm::yaml::Output Yout(llvm::outs());
     Yout << *this;
   } else {
     llvm::SmallString<1024> Buffer;
     llvm::raw_svector_ostream Ostr(Buffer);
     llvm::yaml::Output Yout(Ostr);

unittests/tools/llvm-exegesis/BenchmarkResultTest.cpp

TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   std::error_code EC;
   EC = llvm::sys::fs::createUniqueDirectory("BenchmarkResultTestDir", Filename);
   ASSERT_FALSE(EC);
   llvm::sys::path::append(Filename, "data.yaml");
 
   ToDisk.writeYamlOrDie(Filename);
 
   {
+    // One-element version.
     const auto FromDisk = InstructionBenchmark::readYamlOrDie(Filename);
 
     EXPECT_EQ(FromDisk.AsmTmpl.Name, ToDisk.AsmTmpl.Name);
     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);
   }
+  {
+    // Vector version.
+    const auto FromDiskVector = InstructionBenchmark::readYamlsOrDie(Filename);
+    ASSERT_EQ(FromDiskVector.size(), 1);
+    const auto FromDisk = FromDiskVector[0];
+    EXPECT_EQ(FromDisk.AsmTmpl.Name, ToDisk.AsmTmpl.Name);
+    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);
+  }
 }
 
 } // namespace
 } // namespace exegesis