[llvm-exegesis] Add memory annotation parsing

[aidengrossman]

Summary

This patch adds memory annotation parsing to llvm-exegesis. The memory
annotations cannot be used currently, but this allows for using parsed
memory annotations within a FunctionExecutorImpl to set up a specified
execution environment.

[aidengrossman]

Rebase

[aidengrossman]

Format + rebase

[aidengrossman]

Roll back to previous diff since the last update rolled two commits together.

[aidengrossman]

Rebase + format

[aidengrossman]

Rebase

[aidengrossman]

Rebase

[aidengrossman]

Rebase

[aidengrossman]

Rebase

[aidengrossman]

Rebase

[aidengrossman]

Rebase

[aidengrossman]

Rebase

[aidengrossman]

Updated the wrong patch

[aidengrossman]

Rebase

[aidengrossman]

@courbet This patch (and the next one) are ready for review on my side when you have some time.

[courbet]

llvm/tools/llvm-exegesis/lib/SnippetFile.h

33

From a design perspective I don't think readSnippets should know about ExecutionMode. The parser just parses, let's check in that there are no memory mappings in the BenchmarkCode when using it (e.g. in main).

[aidengrossman]

Address reviewer feedback.

[aidengrossman]

Just updated it to throw an error in llvm-exegesis.cpp rather than generate invalid comments. Definitely a much cleaner design. Thanks for the suggestion!

[aidengrossman]

Should be closed by f0655b0d06129330f710b3cb9955cec7e778bfd0. I forgot to add in the Phabricator information when cherry-picking from my branch with the changes.

llvm/test/tools/llvm-exegesis/X86/memory-annotations-unsupported.test

+# RUN: not llvm-exegesis -snippets-file=%s -mode=latency 2>&1 | FileCheck %s
+
+# CHECK: llvm-exegesis error: Memory annotations are only supported in subprocess execution mode
+
+# LLVM-EXEGESIS-MEM-DEF test1 4096 ff
+
+movq $0, %rax

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

struct MemoryMapping {
   std::string MemoryValueName;
 };
 
 struct BenchmarkKey {
   // The LLVM opcode name.
   std::vector<MCInst> Instructions;
   // The initial values of the registers.
   std::vector<RegisterValue> RegisterInitialValues;
+  // The memory values that can be mapped into the execution context of the
+  // snippet.
+  std::unordered_map<std::string, MemoryValue> MemoryValues;
+  // The memory mappings that the snippet can access.
+  std::vector<MemoryMapping> MemoryMappings;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
 };
 
 struct BenchmarkMeasure {
   // A helper to create an unscaled BenchmarkMeasure.
   static BenchmarkMeasure Create(std::string Key, double Value) {

llvm/tools/llvm-exegesis/lib/SnippetFile.h

 /// registers should be defined or are live on entry.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_SNIPPETFILE_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_SNIPPETFILE_H
 
 #include "BenchmarkCode.h"
+#include "BenchmarkRunner.h"
 #include "LlvmState.h"
 #include "llvm/Support/Error.h"
 
 #include <vector>
 
 namespace llvm {
 namespace exegesis {
 
 // Reads code snippets from file `Filename`.
 Expected<std::vector<BenchmarkCode>> readSnippets(const LLVMState &State,
                                                   StringRef Filename);
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif

llvm/tools/llvm-exegesis/lib/SnippetFile.cpp

 //===-- SnippetFile.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SnippetFile.h"
+#include "BenchmarkRunner.h"
 #include "Error.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
if (CommentText.consume_front("LIVEIN")) {
         Result->LiveIns.push_back(Reg);
       else {
         errs() << "unknown register '" << RegName
                << "' in 'LLVM-EXEGESIS-LIVEIN " << CommentText << "'\n";
         ++InvalidComments;
       }
       return;
     }
+    if (CommentText.consume_front("MEM-DEF")) {
+      // LLVM-EXEGESIS-MEM-DEF <name> <size> <value>
+      SmallVector<StringRef, 3> Parts;
+      CommentText.split(Parts, ' ', -1, false);
+      if (Parts.size() != 3) {
+        errs() << "invalid comment 'LLVM-EXEGESIS-MEM-DEF " << CommentText
+               << "', expected three parameters <NAME> <SIZE> <VALUE>";
+        ++InvalidComments;
+        return;
+      }
+      const StringRef HexValue = Parts[2].trim();
+      MemoryValue MemVal;
+      MemVal.SizeBytes = std::stol(Parts[1].trim().str());
+      if (HexValue.size() % 2 != 0) {
+        errs() << "invalid comment 'LLVM-EXEGESIS-MEM-DEF " << CommentText
+               << "', expected <VALUE> to contain a whole number of bytes";
+      }
+      MemVal.Value = APInt(HexValue.size() * 4, HexValue, 16);
+      MemVal.Index = Result->Key.MemoryValues.size();
+      Result->Key.MemoryValues[Parts[0].trim().str()] = MemVal;
+      return;
+    }
+    if (CommentText.consume_front("MEM-MAP")) {
+      // LLVM-EXEGESIS-MEM-MAP <value name> <address>
+      SmallVector<StringRef, 2> Parts;
+      CommentText.split(Parts, ' ', -1, false);
+      if (Parts.size() != 2) {
+        errs() << "invalid comment 'LLVM-EXEGESIS-MEM-MAP " << CommentText
+               << "', expected two parameters <VALUE NAME> <ADDRESS>";
+        ++InvalidComments;
+        return;
+      }
+      MemoryMapping MemMap;
+      MemMap.MemoryValueName = Parts[0].trim().str();
+      MemMap.Address = std::stol(Parts[1].trim().str());
+      // validate that the annotation refers to an already existing memory
+      // definition
+      auto MemValIT = Result->Key.MemoryValues.find(Parts[0].trim().str());
+      if (MemValIT == Result->Key.MemoryValues.end()) {
+        errs() << "invalid comment 'LLVM-EXEGESIS-MEM-MAP " << CommentText
+               << "', expected <VALUE NAME> to contain the name of an already "
+                  "specified memory definition";
+        ++InvalidComments;
+        return;
+      }
+      Result->Key.MemoryMappings.push_back(std::move(MemMap));
+      return;
+    }
   }
 
   unsigned numInvalidComments() const { return InvalidComments; }
 
 private:
   // We only care about instructions, we don't implement this part of the API.
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         Align ByteAlignment) override {}

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

 /// Measures execution properties (latencies/uops) of an instruction.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "lib/Analysis.h"
 #include "lib/BenchmarkResult.h"
 #include "lib/BenchmarkRunner.h"
 #include "lib/Clustering.h"
+#include "lib/CodeTemplate.h"
 #include "lib/Error.h"
 #include "lib/LlvmState.h"
 #include "lib/PerfHelper.h"
 #include "lib/ProgressMeter.h"
 #include "lib/SnippetFile.h"
 #include "lib/SnippetRepetitor.h"
 #include "lib/Target.h"
 #include "lib/TargetSelect.h"
for (const unsigned Opcode : Opcodes) {
             Twine(State.getInstrInfo().getName(Opcode)).concat(": "));
         continue;
       }
       std::move(ConfigsForInstr->begin(), ConfigsForInstr->end(),
                 std::back_inserter(Configurations));
     }
   } else {
     Configurations = ExitOnErr(readSnippets(State, SnippetsFile));
+    for (const auto &Configuration : Configurations) {
+      if (ExecutionMode != BenchmarkRunner::ExecutionModeE::SubProcess &&
+          (Configuration.Key.MemoryMappings.size() != 0 ||
+           Configuration.Key.MemoryValues.size() != 0))
+        ExitWithError("Memory annotations are only supported in subprocess "
+                      "execution mode");
+    }
   }
 
   if (NumRepetitions == 0) {
     ExitOnErr.setBanner("llvm-exegesis: ");
     ExitWithError("--num-repetitions must be greater than zero");
   }
 
   // Write to standard output if file is not set.

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

 namespace {
 
 using testing::AllOf;
 using testing::ElementsAre;
 using testing::Eq;
 using testing::Field;
 using testing::Property;
 using testing::SizeIs;
+using testing::UnorderedElementsAre;
 
 using llvm::unittest::TempDir;
 
 class X86SnippetFileTest : public X86TestBase {
 protected:
   Expected<std::vector<BenchmarkCode>> TestCommon(StringRef Contents) {
     TempDir TestDirectory("SnippetFileTestDir", /*Unique*/ true);
     SmallString<64> Filename(TestDirectory.path());
if (arg.Register == Reg &&
       arg.Value.getLimitedValue() == static_cast<uint64_t>(Val))
     return true;
   *result_listener << "expected: {" << Reg << ", " << Val << "} ";
   *result_listener << "actual: {" << arg.Register << ", "
                    << arg.Value.getLimitedValue() << "}";
   return false;
 }
 
+MATCHER_P3(MemoryDefinitionIs, Name, Value, Size, "") {
+  if (arg.second.Value.getLimitedValue() == static_cast<uint64_t>(Value) &&
+      arg.second.SizeBytes == static_cast<size_t>(Size) && arg.first == Name)
+    return true;
+  *result_listener << "expected: {" << Name << ", " << Value << ", " << Size
+                   << "} ";
+  *result_listener << "actual: {" << arg.first << ", "
+                   << arg.second.Value.getLimitedValue() << ", "
+                   << arg.second.SizeBytes << "}";
+  return false;
+}
+
+MATCHER_P2(MemoryMappingIs, Address, Name, "") {
+  if (arg.Address == Address && arg.MemoryValueName == Name)
+    return true;
+  *result_listener << "expected: {" << Address << ", " << Name << "} ";
+  *result_listener << "actual: {" << arg.Address << ", " << arg.MemoryValueName
+                   << "}";
+  return false;
+}
+
 TEST_F(X86SnippetFileTest, Works) {
   auto Snippets = TestCommon(R"(
     # LLVM-EXEGESIS-DEFREG RAX 0f
     # LLVM-EXEGESIS-DEFREG SIL 0
     # LLVM-EXEGESIS-LIVEIN RDI
     # LLVM-EXEGESIS-LIVEIN DL
     incq %rax
   )");

 
 TEST_F(X86SnippetFileTest, NoAsmStreamer) {
   auto Snippets = TestCommon(R"(
     .cv_fpo_proc foo 4
   )");
   EXPECT_FALSE((bool)Snippets.takeError());
 }
 
+TEST_F(X86SnippetFileTest, MemoryDefinitionTestSingleDef) {
+  auto Snippets = TestCommon(R"(
+    # LLVM-EXEGESIS-MEM-DEF test1 4096 ff
+    # LLVM-EXEGESIS-MEM-MAP test1 8192
+    # LLVM-EXEGESIS-MEM-MAP test1 16384
+    movq $8192, %r10
+    movq (%r10), %r11
+  )");
+  EXPECT_FALSE((bool)Snippets.takeError());
+  ASSERT_THAT(*Snippets, SizeIs(1));
+  const auto &Snippet = (*Snippets)[0];
+  ASSERT_THAT(Snippet.Key.MemoryValues,
+              UnorderedElementsAre(MemoryDefinitionIs("test1", 255, 4096)));
+  ASSERT_THAT(Snippet.Key.MemoryMappings,
+              ElementsAre(MemoryMappingIs(8192, "test1"),
+                          MemoryMappingIs(16384, "test1")));
+}
+
+TEST_F(X86SnippetFileTest, MemoryDefinitionsTestTwoDef) {
+  auto Snippets = TestCommon(R"(
+    # LLVM-EXEGESIS-MEM-DEF test1 4096 ff
+    # LLVM-EXEGESIS-MEM-DEF test2 4096 100
+    # LLVM-EXEGESIS-MEM-MAP test1 8192
+    # LLVM-EXEGESIS-MEM-MAP test2 16384
+    movq $8192, %r10
+    movq (%r10), %r11
+  )");
+  EXPECT_FALSE((bool)Snippets.takeError());
+  ASSERT_THAT(*Snippets, SizeIs(1));
+  const auto &Snippet = (*Snippets)[0];
+  ASSERT_THAT(Snippet.Key.MemoryValues,
+              UnorderedElementsAre(MemoryDefinitionIs("test1", 255, 4096),
+                                   MemoryDefinitionIs("test2", 256, 4096)));
+  ASSERT_THAT(Snippet.Key.MemoryMappings,
+              ElementsAre(MemoryMappingIs(8192, "test1"),
+                          MemoryMappingIs(16384, "test2")));
+}
+
+TEST_F(X86SnippetFileTest, MemoryDefinitionMissingParameter) {
+  auto Error = TestCommon(R"(
+    # LLVM-EXEGESIS-MEM-DEF test1 4096
+  )")
+                   .takeError();
+  EXPECT_TRUE((bool)Error);
+  consumeError(std::move(Error));
+}
+
+TEST_F(X86SnippetFileTest, MemoryMappingMissingParameters) {
+  auto Error = TestCommon(R"(
+    # LLVM-EXEGESIS-MEM-MAP test1
+  )")
+                   .takeError();
+  EXPECT_TRUE((bool)Error);
+  consumeError(std::move(Error));
+}
+
+TEST_F(X86SnippetFileTest, MemoryMappingNoDefinition) {
+  auto Error = TestCommon(R"(
+    # LLVM-EXEGESIS-MEM-MAP test1 4096
+  )")
+                   .takeError();
+  EXPECT_TRUE((bool)Error);
+  consumeError(std::move(Error));
+}
+
+TEST_F(X86SnippetFileTest, IncompatibleExecutorMode) {
+  auto Error = TestCommon(R"(
+    # LLVM-EXEGESIS-MEM-MAP test1 4096
+  )")
+                   .takeError();
+  EXPECT_TRUE((bool)Error);
+  consumeError(std::move(Error));
+}
+
 } // namespace
 } // namespace exegesis
 } // namespace llvm