[llvm-exegesis] Refactor FunctionExecutorImpl and create factory

[aidengrossman]

Summary

In order to better support adding in new implementations of
FunctionExecutor, this patch makes some small changes so that it is
easier to add new ones in. FunctionExecutorImpl is renamed to
InProcessFunctionExecutorImpl to better reflect how it will be placed
relative to the soon-to-be introduced subprocess executor and a new
function is created to create executors so selection can be done more
easily. In addition, a new CLI flag, -execution-mode, which can be used
to select between the different executors.

[courbet]

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

195

A runnable configuration exists outside of how it's executed, it feels weird to have this here. Why isn't this a member of BenchmarkRunner ?

204

Why do we need Key ?

205

[nit] use switch, even if it's only one option for now, I think it's more readable for enums.

[aidengrossman]

Address reviewer feedback.

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

195

Good point. I've switched it over to being a member of BenchmarkRunner.

204

I'm using a BenchmarkKey in https://reviews.llvm.org/D151025 (and touching it in some previous patches in the stack) to pass around memory annotations, and the way I have it structured currently, I pass the key to the FunctionExecutorImpl for setup. I can move this to another diff/change this around if desired.

[courbet]

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

128

[nit] createFunctionExecutor ?

[aidengrossman]

Address reviewer feedback.

[aidengrossman]

Format

[aidengrossman]

Update

[aidengrossman]

Rebase

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

 
   virtual ~BenchmarkRunner();
 
+  enum ExecutionModeE { InProcess };
+
   class RunnableConfiguration {
     friend class BenchmarkRunner;
 

 
     Benchmark InstrBenchmark;
     object::OwningBinary<object::ObjectFile> ObjectFile;
+    ExecutionModeE ExecutionMode;
   };
 
   Expected<RunnableConfiguration>
   getRunnableConfiguration(const BenchmarkCode &Configuration,
                            unsigned NumRepetitions, unsigned LoopUnrollFactor,
-                           const SnippetRepetitor &Repetitor) const;
+                           const SnippetRepetitor &Repetitor,
+                           ExecutionModeE ExecutionMode) const;
 
   Expected<Benchmark>
   runConfiguration(RunnableConfiguration &&RC,

                                         StringRef FileName) const;
 
   const std::unique_ptr<ScratchSpace> Scratch;
+
+  Expected<std::unique_ptr<FunctionExecutor>>
+  getFunctionExecutor(ExecutionModeE ExecutionMode,
+                      object::OwningBinary<object::ObjectFile> Obj,
+                      const BenchmarkKey &Key) const;
 };
 
 } // namespace exegesis

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

 
 #include "Assembler.h"
 #include "BenchmarkRunner.h"
+#include "CodeTemplate.h"
 #include "Error.h"
 #include "MCInstrDescView.h"
 #include "PerfHelper.h"

 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"

 }
 
 namespace {
-class FunctionExecutorImpl : public BenchmarkRunner::FunctionExecutor {
+class InProcessFunctionExecutorImpl : public BenchmarkRunner::FunctionExecutor {
 public:
-  FunctionExecutorImpl(const LLVMState &State,
+  InProcessFunctionExecutorImpl(const LLVMState &State,
                        object::OwningBinary<object::ObjectFile> Obj,
                        BenchmarkRunner::ScratchSpace *Scratch)
       : State(State), Function(State.createTargetMachine(), std::move(Obj)),

 Expected<BenchmarkRunner::RunnableConfiguration>
 BenchmarkRunner::getRunnableConfiguration(
     const BenchmarkCode &BC, unsigned NumRepetitions, unsigned LoopBodySize,
-    const SnippetRepetitor &Repetitor) const {
+    const SnippetRepetitor &Repetitor, ExecutionModeE ExecutionMode) const {
   RunnableConfiguration RC;
 
   Benchmark &InstrBenchmark = RC.InstrBenchmark;

     RC.ObjectFile = getObjectFromBuffer(*Snippet);
   }
 
+  RC.ExecutionMode = ExecutionMode;
+
   return std::move(RC);
 }
 
+Expected<std::unique_ptr<BenchmarkRunner::FunctionExecutor>>
+BenchmarkRunner::getFunctionExecutor(
+    ExecutionModeE ExecutionMode,
+    object::OwningBinary<object::ObjectFile> ObjectFile,
+    const BenchmarkKey &Key) const {
+  if (ExecutionMode == ExecutionModeE::InProcess) {
+    return std::make_unique<InProcessFunctionExecutorImpl>(
+        State, std::move(ObjectFile), Scratch.get());
+  }
+  llvm_unreachable("ExecutionMode is outside expected range");
+}
+
 Expected<Benchmark> BenchmarkRunner::runConfiguration(
     RunnableConfiguration &&RC,
     const std::optional<StringRef> &DumpFile) const {

     return std::move(InstrBenchmark);
   }
 
-  const FunctionExecutorImpl Executor(State, std::move(ObjectFile),
-                                      Scratch.get());
-  auto NewMeasurements = runMeasurements(Executor);
+  Expected<std::unique_ptr<BenchmarkRunner::FunctionExecutor>> Executor =
+      getFunctionExecutor(RC.ExecutionMode, std::move(ObjectFile),
+                          RC.InstrBenchmark.Key);
+  if (!Executor)
+    return Executor.takeError();
+  auto NewMeasurements = runMeasurements(**Executor);
+
   if (Error E = NewMeasurements.takeError()) {
     if (!E.isA<SnippetCrash>())
       return std::move(E);

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

 #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"

                               "and prints a message to access it"),
                      cl::ValueOptional, cl::cat(BenchmarkOptions));
 
+static cl::opt<BenchmarkRunner::ExecutionModeE> ExecutionMode(
+    "execution-mode",
+    cl::desc("Selects the execution mode to use for running snippets"),
+    cl::cat(BenchmarkOptions),
+    cl::values(clEnumValN(BenchmarkRunner::ExecutionModeE::InProcess,
+                          "inprocess",
+                          "Executes the snippets within the same process")),
+    cl::init(BenchmarkRunner::ExecutionModeE::InProcess));
+
 static ExitOnError ExitOnErr("llvm-exegesis error: ");
 
 // Helper function that logs the error(s) and exits.

     for (const std::unique_ptr<const SnippetRepetitor> &Repetitor :
          Repetitors) {
       auto RC = ExitOnErr(Runner.getRunnableConfiguration(
-          Conf, NumRepetitions, LoopBodySize, *Repetitor));
+          Conf, NumRepetitions, LoopBodySize, *Repetitor, ExecutionMode));
       std::optional<StringRef> DumpFile;
       if (DumpObjectToDisk.getNumOccurrences())
         DumpFile = DumpObjectToDisk;