Add an option do not dump the generated object on disk

[courbet]

tools/llvm-exegesis/lib/BenchmarkRunner.cpp

135 ↗

(On Diff #193877)

This should go outside the if.

[gchatelet]

• Move comment to the right line.

llvm/trunk/docs/CommandGuide/llvm-exegesis.rst

  not being clustered into the same cluster if the measured performance
  characteristics are different. by default all such opcodes are filtered out.
  This flag will instead show only such unstable opcodes.
 
 .. option:: -ignore-invalid-sched-class=false
 
  If set, ignore instructions that do not have a sched class (class idx = 0).
 
- .. option:: -mcpu=<cpu name>
 
-  If set, measure the cpu characteristics using the counters for this CPU. This
-  is useful when creating new sched models (the host CPU is unknown to LLVM).
 
+.. option:: --dump-object-to-disk=true
+
+ By default, llvm-exegesis will dump the generated code to a temporary file to
+ enable code inspection. You may disable it to speed up the execution and save
+ disk space.
+
 EXIT STATUS
 -----------
 
 :program:`llvm-exegesis` returns 0 on success. Otherwise, an error message is
 printed to standard error, and the tool returns a non 0 value.

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

 class BenchmarkRunner {
 public:
   explicit BenchmarkRunner(const LLVMState &State,
                            InstructionBenchmark::ModeE Mode);
 
   virtual ~BenchmarkRunner();
 
   InstructionBenchmark runConfiguration(const BenchmarkCode &Configuration,
-                                        unsigned NumRepetitions) const;
+                                        unsigned NumRepetitions,
+                                        bool DumpObjectToDisk) const;
 
   // Scratch space to run instructions that touch memory.
   struct ScratchSpace {
     static constexpr const size_t kAlignment = 1024;
     static constexpr const size_t kSize = 1 << 20; // 1MB.
     ScratchSpace()
         : UnalignedPtr(llvm::make_unique<char[]>(kSize + kAlignment)),
           AlignedPtr(

 private:
   virtual llvm::Expected<std::vector<BenchmarkMeasure>>
   runMeasurements(const FunctionExecutor &Executor) const = 0;
 
   llvm::Expected<std::string>
   writeObjectFile(const BenchmarkCode &Configuration,
                   llvm::ArrayRef<llvm::MCInst> Code) const;
 
-
   const std::unique_ptr<ScratchSpace> Scratch;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRUNNER_H

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

llvm::Expected<int64_t> runAndMeasure(const char *Counters) const override {
     int64_t CounterValue = 0;
     llvm::SmallVector<llvm::StringRef, 2> CounterNames;
     llvm::StringRef(Counters).split(CounterNames, '+');
     char *const ScratchPtr = Scratch->ptr();
     for (auto &CounterName : CounterNames) {
       CounterName = CounterName.trim();
       pfm::PerfEvent PerfEvent(CounterName);
       if (!PerfEvent.valid())
-        llvm::report_fatal_error(
-            llvm::Twine("invalid perf event '").concat(CounterName).concat("'"));
+        llvm::report_fatal_error(llvm::Twine("invalid perf event '")
+                                     .concat(CounterName)
+                                     .concat("'"));
       pfm::Counter Counter(PerfEvent);
       Scratch->clear();
       {
         llvm::CrashRecoveryContext CRC;
         llvm::CrashRecoveryContext::Enable();
         const bool Crashed = !CRC.RunSafely([this, &Counter, ScratchPtr]() {
           Counter.start();
           this->Function(ScratchPtr);
private:
 
   const ExecutableFunction Function;
   BenchmarkRunner::ScratchSpace *const Scratch;
 };
 } // namespace
 
 InstructionBenchmark
 BenchmarkRunner::runConfiguration(const BenchmarkCode &BC,
-                                  unsigned NumRepetitions) const {
+                                  unsigned NumRepetitions,
+                                  bool DumpObjectToDisk) const {
   InstructionBenchmark InstrBenchmark;
   InstrBenchmark.Mode = Mode;
   InstrBenchmark.CpuName = State.getTargetMachine().getTargetCPU();
   InstrBenchmark.LLVMTriple =
       State.getTargetMachine().getTargetTriple().normalize();
   InstrBenchmark.NumRepetitions = NumRepetitions;
   InstrBenchmark.Info = BC.Info;
 
constexpr const int kMinInstructionsForSnippet = 16;
     const ExecutableFunction EF(State.createTargetMachine(),
                                 getObjectFromFile(*ObjectFilePath));
     const auto FnBytes = EF.getFunctionBytes();
     InstrBenchmark.AssembledSnippet.assign(FnBytes.begin(), FnBytes.end());
   }
 
   // Assemble NumRepetitions instructions repetitions of the snippet for
   // measurements.
-  auto ObjectFilePath = writeObjectFile(
-      BC, GenerateInstructions(BC, InstrBenchmark.NumRepetitions));
+  const auto Code = GenerateInstructions(BC, InstrBenchmark.NumRepetitions);
+
+  llvm::object::OwningBinary<llvm::object::ObjectFile> ObjectFile;
+  if (DumpObjectToDisk) {
+    auto ObjectFilePath = writeObjectFile(BC, Code);
     if (llvm::Error E = ObjectFilePath.takeError()) {
       InstrBenchmark.Error = llvm::toString(std::move(E));
       return InstrBenchmark;
     }
     llvm::outs() << "Check generated assembly with: /usr/bin/objdump -d "
                  << *ObjectFilePath << "\n";
-  const FunctionExecutorImpl Executor(State, getObjectFromFile(*ObjectFilePath),
+    ObjectFile = getObjectFromFile(*ObjectFilePath);
+  } else {
+    llvm::SmallString<0> Buffer;
+    llvm::raw_svector_ostream OS(Buffer);
+    assembleToStream(State.getExegesisTarget(), State.createTargetMachine(),
+                     BC.LiveIns, BC.RegisterInitialValues, Code, OS);
+    ObjectFile = getObjectFromBuffer(OS.str());
+  }
+
+  const FunctionExecutorImpl Executor(State, std::move(ObjectFile),
                                       Scratch.get());
   auto Measurements = runMeasurements(Executor);
   if (llvm::Error E = Measurements.takeError()) {
     InstrBenchmark.Error = llvm::toString(std::move(E));
     return InstrBenchmark;
   }
   InstrBenchmark.Measurements = std::move(*Measurements);
   assert(InstrBenchmark.NumRepetitions > 0 && "invalid NumRepetitions");

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

cl::desc("if there is more than one benchmark for an opcode, said "
              "instead show only such unstable opcodes"),
     cl::cat(AnalysisOptions), cl::init(false));
 
 static cl::opt<std::string> CpuName(
     "mcpu",
     cl::desc("cpu name to use for pfm counters, leave empty to autodetect"),
     cl::cat(Options), cl::init(""));
 
+static cl::opt<bool>
+    DumpObjectToDisk("dump-object-to-disk",
+                     cl::desc("dumps the generated benchmark object to disk "
+                              "and prints a message to access it"),
+                     cl::cat(BenchmarkOptions), cl::init(true));
+
 static ExitOnError ExitOnErr;
 
 #ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
 void LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
 #endif
 
 // Checks that only one of OpcodeNames, OpcodeIndex or SnippetsFile is provided,
 // and returns the opcode indices or {} if snippets should be read from
if (NumRepetitions == 0)
     llvm::report_fatal_error("--num-repetitions must be greater than zero");
 
   // Write to standard output if file is not set.
   if (BenchmarkFile.empty())
     BenchmarkFile = "-";
 
   for (const BenchmarkCode &Conf : Configurations) {
     InstructionBenchmark Result =
-        Runner->runConfiguration(Conf, NumRepetitions);
+        Runner->runConfiguration(Conf, NumRepetitions, DumpObjectToDisk);
     ExitOnErr(Result.writeYaml(State, BenchmarkFile));
   }
   exegesis::pfm::pfmTerminate();
 }
 
 // Prints the results of running analysis pass `Pass` to file `OutputFilename`
 // if OutputFilename is non-empty.
 template <typename Pass>