[llvm-exegesis] Add subprocess benchmarking mode

[aidengrossman]

Summary

This patch adds in a a new flag (--benchmark-subprocess) that enables
benchmarking within a subprocess. This is necessary for implementing the
plane described in our annotation RFC
(https://discourse.llvm.org/t/rfc-memory-annotations-for-llvm-exegesis/69554)
as we need to have a lot more control over the memory layout of the
execution environment than is possible by doing everything in a single
process.

[aidengrossman]

This patch adds in the subprocess benchmarking mode (phase 1 of the RFC linked in the description). I can understand some hesitancy on getting this pushed through since the RFC hasn't been discussed thoroughly, so I can definitely wait until we have everything nailed down there if necessary. After this patch, I plan on working on an assembly test harness so that we have the control over memory that we need and then I plan on adding the proposed annotations.

Hopefully this code isn't too hacky and review isn't too difficult. I have never worked with low level process control functions on Linux in a production environment before (e.g., still have never experienced most of the footguns of fork()).

There are two minor issues with this patch that I still need to address, namely that it only supports sending a single CounterValue from the benchmarking process to the llvm-exegesis process (so LBR doesn't work), and that there are some slight systematic differences in measurements between the subprocess mode and the in-process mode (at least on my system, dual socket E5-2670 sandy bridge). I haven't done a ton of investigation into why this issue is occurring, but it is relatively minor (only about a 1% difference), and I imagine should be alleviated once we switch to the assembly test harness (if that's the route we end up going down).

[aidengrossman]

Rebase.

[aidengrossman]

Planning on reworking the way the performance counters are passed between the parent and child process to allow for better reading in the parent process/easier usage in the child process as the first annotation implementation evolves.

[aidengrossman]

This has been superseded by https://reviews.llvm.org/D151021.

llvm/test/tools/llvm-exegesis/X86/latency/Inputs/abnormal-exit-code.s

+movl $60, %eax
+movl $1, %edi
+syscall

llvm/test/tools/llvm-exegesis/X86/latency/Inputs/base-snippet.s

+# LLVM-EXEGESIS-DEFREG XMM1 42
+# LLVM-EXEGESIS-DEFREG XMM2 42
+# LLVM-EXEGESIS-DEFREG XMM3 42
+vhaddps       %xmm2, %xmm2, %xmm3

llvm/test/tools/llvm-exegesis/X86/latency/Inputs/snippet-segfault.s

+# LLVM-EXEGESIS-LIVEIN RDI
+# LLVM-EXEGESIS-DEFREG XMM1 42
+# LLVM-EXEGESIS-DEFREG RBX 0
+vmulps        (%rbx), %xmm1, %xmm2
+vhaddps       %xmm2, %xmm2, %xmm3
+addq $0x10, %rbx

llvm/test/tools/llvm-exegesis/X86/latency/subprocess-abnormal-exit-code.test

+# REQUIRES: exegesis-can-execute-x86_64, exegesis-can-measure-latency, x86_64-linux
+
+# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mode=latency -snippets-file=%S/Inputs/abnormal-exit-code.s --benchmark-subprocess > /test.out
+
+CHECK: error:           Child benchmarking process exited with non-zero exit code1

llvm/test/tools/llvm-exegesis/X86/latency/subprocess-segfault.test

+# REQUIRES: exegesis-can-execute-x86_64, exegesis-can-measure-latency, x86_64-linux
+
+# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mode=latency -snippets-file=%S/Inputs/snippet-segfault.s --benchmark-subprocess | FileCheck %s
+
+CHECK: error:           'The benchmarking subprocess sent unexpected signal: Segmentation fault'

llvm/test/tools/llvm-exegesis/X86/latency/subprocess.test

+# REQUIRES: exegesis-can-execute-x86_64, exegesis-can-measure-latency, x86_64-linux
+
+# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mode=latency -snippets-file=%S/Inputs/base-snippet.s --benchmark-subprocess | FileCheck %s
+
+CHECK: measurements:
+CHECK-NEXT: value: {{.*}}, per_snippet_value: {{.*}}

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

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
+#include "llvm/Support/Signals.h"
+
+#ifdef LLVM_ON_UNIX
+#include "sys/wait.h"
+#include "sys/ptrace.h"
+#endif
 
 namespace llvm {
 namespace exegesis {
 
+static cl::opt<bool> BenchmarkInSubprocess(
+  "benchmark-subprocess",
+  cl::desc("Enabling this makes benchmarking occur in a subprocess"),
+  cl::cat(BenchmarkOptions), cl::init(false));
+
 BenchmarkRunner::BenchmarkRunner(const LLVMState &State,
                                  Benchmark::ModeE Mode,
                                  BenchmarkPhaseSelectorE BenchmarkPhaseSelector)
     : State(State), Mode(Mode), BenchmarkPhaseSelector(BenchmarkPhaseSelector),
       Scratch(std::make_unique<ScratchSpace>()) {}
 
 BenchmarkRunner::~BenchmarkRunner() = default;
 
#endif
 
     return Counter->readOrError(Function.getFunctionBytes());
   }
 
   const LLVMState &State;
   const ExecutableFunction Function;
   BenchmarkRunner::ScratchSpace *const Scratch;
 };
+
+#ifdef LLVM_ON_UNIX
+class SubProcessFunctionExecutorImpl
+    : public BenchmarkRunner::FunctionExecutor {
+public:
+  SubProcessFunctionExecutorImpl(const LLVMState &State,
+                                 object::OwningBinary<object::ObjectFile> Obj)
+      : State(State), Function(State.createTargetMachine(), std::move(Obj)) {}
+
+private:
+  Error
+  createProcessAndRunBenchmark(StringRef CounterName,
+                               SmallVectorImpl<int64_t> &CounterValues) const {
+    int PipeFiles[2];
+    int PipeSuccessOrErr = pipe(PipeFiles);
+    if (PipeSuccessOrErr != 0) {
+      return make_error<Failure>(
+          "Failed to create a pipe for interprocess communication between "
+          "llvm-exegesis and the benchmarking subprocess");
+    }
+    pid_t ParentOrChildPID = fork();
+    if(ParentOrChildPID == 0) {
+      // We are in the child process
+      close(PipeFiles[0]);
+      // Unregister handlers, signal handling is now handled through ptrace in
+      // the host process
+      llvm::sys::unregisterHandlers();
+      prepareAndRunBenchmark(CounterName, PipeFiles[1]);
+    }
+
+    ptrace(PTRACE_SEIZE, ParentOrChildPID, NULL, NULL);
+
+    close(PipeFiles[1]);
+
+    int ChildStatus;
+    wait(&ChildStatus);
+
+    if(WIFEXITED(ChildStatus)) {
+      if (WEXITSTATUS(ChildStatus) == 0) {
+          // The child exited succesfully, read counter values and return
+          // success
+          int64_t CounterValue;
+          ssize_t BytesRead =
+              read(PipeFiles[0], &CounterValue, sizeof(CounterValue));
+          if (BytesRead != sizeof(CounterValue)) {
+            return make_error<Failure>(
+                "Counter data size sent by the subprocess "
+                "does not match the expected size");
+          }
+          CounterValues[0] = CounterValue;
+          return Error::success();
+      }
+      // The child exited, but not successfully
+      return make_error<SnippetCrash>(
+          "Child benchmarking process exited with non-zero exit code" +
+          Twine(WEXITSTATUS(ChildStatus)));
+    }
+
+    // An error was encountered running the snippet, process it
+    siginfo_t ChildSignalInfo;
+    ptrace(PTRACE_GETSIGINFO, ParentOrChildPID, NULL, &ChildSignalInfo);
+
+    return make_error<SnippetCrash>(
+        "The benchmarking subprocess sent unexpected signal: " +
+        Twine(strsignal(ChildSignalInfo.si_signo)));
+  }
+
+  void prepareAndRunBenchmark(StringRef CounterName, int Pipe) const {
+    // The following occurs within the benchmarking subprocess
+    auto Scratch = std::make_unique<BenchmarkRunner::ScratchSpace>();
+    Scratch->clear();
+
+    const ExegesisTarget &ET = State.getExegesisTarget();
+    auto CounterOrError = ET.createCounter(CounterName, State);
+    if(CounterOrError) {
+      pfm::Counter *Counter = CounterOrError.get().get();
+
+      StringRef FunctionData = Function.getFunctionBytes();
+      std::string FunctionDataCopy = FunctionData.str();
+      Counter->start();
+      this->Function(Scratch->ptr());
+      Counter->stop();
+      int64_t CounterValue = Counter->read();
+      ssize_t BytesWritten = write(Pipe, &CounterValue, sizeof(CounterValue));
+      if(BytesWritten != sizeof(CounterValue)) {
+        exit(1);
+      }
+    }
+
+    exit(0);
+  }
+
+  Expected<llvm::SmallVector<int64_t, 4>>
+  runWithCounter(StringRef CounterName) const override {
+    SmallVector<int64_t, 4> Value(1, 0);
+    Error PossibleBenchmarkError =
+        createProcessAndRunBenchmark(CounterName, Value);
+
+    if (PossibleBenchmarkError) {
+      return std::move(PossibleBenchmarkError);
+    }
+
+    return Value;
+  }
+
+  const LLVMState &State;
+  const ExecutableFunction Function;
+};
+#endif // LLVM_ON_UNIX
 } // namespace
 
 Expected<SmallString<0>> BenchmarkRunner::assembleSnippet(
     const BenchmarkCode &BC, const SnippetRepetitor &Repetitor,
     unsigned MinInstructions, unsigned LoopBodySize) const {
   const std::vector<MCInst> &Instructions = BC.Key.Instructions;
   SmallString<0> Buffer;
   raw_svector_ostream OS(Buffer);
outs() << "Check generated assembly with: /usr/bin/objdump -d "
            << *ObjectFilePath << "\n";
   }
 
   if (BenchmarkPhaseSelector < BenchmarkPhaseSelectorE::Measure) {
     InstrBenchmark.Error = "actual measurements skipped.";
     return std::move(InstrBenchmark);
   }
 
-  const FunctionExecutorImpl Executor(State, std::move(ObjectFile),
-                                      Scratch.get());
-  auto NewMeasurements = runMeasurements(Executor);
+  FunctionExecutor *Executor;
+  if (!BenchmarkInSubprocess) {
+    Executor =
+        new FunctionExecutorImpl(State, std::move(ObjectFile), Scratch.get());
+  } else {
+#ifdef LLVM_ON_UNIX
+    Executor = new SubProcessFunctionExecutorImpl(State, std::move(ObjectFile));
+#else
+    return make_error<Failure>(
+        "--benchmark-subprocess is not supported on non-UNIX platforms");
+#endif
+  }
+  auto NewMeasurements = runMeasurements(*Executor);
   if (Error E = NewMeasurements.takeError()) {
     if (!E.isA<SnippetCrash>())
       return std::move(E);
     InstrBenchmark.Error = toString(std::move(E));
     return std::move(InstrBenchmark);
   }
   assert(InstrBenchmark.NumRepetitions > 0 && "invalid NumRepetitions");
   for (BenchmarkMeasure &BM : *NewMeasurements) {
     // Scale the measurements by instruction.
     BM.PerInstructionValue /= InstrBenchmark.NumRepetitions;
     // Scale the measurements by snippet.
     BM.PerSnippetValue *=
         static_cast<double>(InstrBenchmark.Key.Instructions.size()) /
         InstrBenchmark.NumRepetitions;
   }
   InstrBenchmark.Measurements = std::move(*NewMeasurements);
 
+#ifdef LLVM_ON_UNIX
+  if (BenchmarkInSubprocess)
+    delete (SubProcessFunctionExecutorImpl *)Executor;
+  else
+    delete (FunctionExecutorImpl *)Executor;
+#else
+  delete (FunctionExecutorImpl *)Executor;
+#endif
+
   return std::move(InstrBenchmark);
 }
 
 Expected<std::string> BenchmarkRunner::writeObjectFile(StringRef Buffer) const {
   int ResultFD = 0;
   SmallString<256> ResultPath;
   if (Error E = errorCodeToError(
           sys::fs::createTemporaryFile("snippet", "o", ResultFD, ResultPath)))