[llvm-exegesis] Allow setting dump file name

[kpdev42]

Summary

This will be used for writing test cases.

~~

Huawei RRI, OS Lab

[courbet]

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

67–68

Given that DumpFileName only makes sense if DumpObjectToDisk, use a single optional<StringRef> parameter ?

[kpdev42]

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

67–68

If we provide just -dump-object-to-disk then llvm-exegesis will use autogenerated name. This is useful when batch opcode testing is used (with -opcode-index=-1). We can use some special file name for this mode, but it looks slightly counter-intuitive.

[courbet]

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

67–68

If we provide just -dump-object-to-disk then llvm-exegesis will use autogenerated name

Yes, and that would be {""}. My point is that we can condense two parameters in one and ensure that we can't write runConfiguration(RC, false, "file"), which makes no sense.

[kpdev42]

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

67–68

Oh, sorry, now I understood what you meant. I will update the revision

[kpdev42]

Address review comments

[kpdev42]

ping

[courbet]

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

67–68

I don't see the optional<StringRef> :)

[kpdev42]

Address review comments

[kpdev42]

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

67–68

Oh, yes. Now it is here )

llvm/test/tools/llvm-exegesis/X86/latency/dump-object-to-disk.s

 
 # RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=prepare-snippet -opcode-name=ADDPSrr -repetition-mode=duplicate -dump-object-to-disk=1 2>&1 | FileCheck %s --check-prefix=CHECK-OFF
 # RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=prepare-snippet -opcode-name=ADDPSrr -repetition-mode=loop      -dump-object-to-disk=1 2>&1 | FileCheck %s --check-prefix=CHECK-OFF
 # RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=prepare-snippet -opcode-name=ADDPSrr -repetition-mode=duplicate -dump-object-to-disk=0 2>&1 | FileCheck %s --check-prefix=CHECK-OFF
 # RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=prepare-snippet -opcode-name=ADDPSrr -repetition-mode=loop      -dump-object-to-disk=0 2>&1 | FileCheck %s --check-prefix=CHECK-OFF
 # RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=prepare-snippet -opcode-name=ADDPSrr -repetition-mode=duplicate 2>&1 | FileCheck %s --check-prefix=CHECK-OFF
 # RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=prepare-snippet -opcode-name=ADDPSrr -repetition-mode=loop 2>&1 | FileCheck %s --check-prefix=CHECK-OFF
 
+# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=assemble-measured-code -opcode-name=ADDPSrr -repetition-mode=duplicate -dump-object-to-disk=1 --dump-file-name=%t.mydmpfile.o 2>&1 | FileCheck %s --check-prefix=DUMP-FILE-NAME
+# RUN: llvm-objdump -d %t.mydmpfile.o | FileCheck %s --check-prefix=ASM
 CHECK-ON: Check generated assembly with
 CHECK-OFF-NOT: Check generated assembly with
+DUMP-FILE-NAME: Check generated assembly with: {{.*}}objdump -d {{.*}}mydmpfile
+ASM: addps
+ASM: retq

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

public:
   };
 
   Expected<RunnableConfiguration>
   getRunnableConfiguration(const BenchmarkCode &Configuration,
                            unsigned NumRepetitions, unsigned LoopUnrollFactor,
                            const SnippetRepetitor &Repetitor) const;
 
   Expected<Benchmark> runConfiguration(RunnableConfiguration &&RC,
-                                                  bool DumpObjectToDisk) const;
+                                       bool DumpObjectToDisk,
+                                       StringRef DumpFileName) 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(std::make_unique<char[]>(kSize + kAlignment)),
           AlignedPtr(
private:
   virtual Expected<std::vector<BenchmarkMeasure>>
   runMeasurements(const FunctionExecutor &Executor) const = 0;
 
   Expected<SmallString<0>> assembleSnippet(const BenchmarkCode &BC,
                                            const SnippetRepetitor &Repetitor,
                                            unsigned MinInstructions,
                                            unsigned LoopBodySize) const;
 
-  Expected<std::string> writeObjectFile(StringRef Buffer) const;
+  Expected<std::string> writeObjectFile(StringRef Buffer,
+                                        StringRef FileName) const;
 
   const std::unique_ptr<ScratchSpace> Scratch;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRUNNER_H

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

if (BenchmarkPhaseSelector > BenchmarkPhaseSelectorE::PrepareAndAssembleSnippet) {
     RC.ObjectFile = getObjectFromBuffer(*Snippet);
   }
 
   return std::move(RC);
 }
 
 Expected<Benchmark>
 BenchmarkRunner::runConfiguration(RunnableConfiguration &&RC,
-                                  bool DumpObjectToDisk) const {
+                                  bool DumpObjectToDisk,
+                                  StringRef DumpFileName) const {
   Benchmark &InstrBenchmark = RC.InstrBenchmark;
   object::OwningBinary<object::ObjectFile> &ObjectFile = RC.ObjectFile;
 
   if (DumpObjectToDisk &&
       BenchmarkPhaseSelector > BenchmarkPhaseSelectorE::PrepareAndAssembleSnippet) {
-    auto ObjectFilePath = writeObjectFile(ObjectFile.getBinary()->getData());
+    auto ObjectFilePath =
+        writeObjectFile(ObjectFile.getBinary()->getData(), DumpFileName);
     if (Error E = ObjectFilePath.takeError()) {
       InstrBenchmark.Error = toString(std::move(E));
       return std::move(InstrBenchmark);
     }
     outs() << "Check generated assembly with: /usr/bin/objdump -d "
            << *ObjectFilePath << "\n";
   }
 
BM.PerSnippetValue *=
         static_cast<double>(InstrBenchmark.Key.Instructions.size()) /
         InstrBenchmark.NumRepetitions;
   }
   InstrBenchmark.Measurements = std::move(*NewMeasurements);
 
   return std::move(InstrBenchmark);
 }
 
-Expected<std::string> BenchmarkRunner::writeObjectFile(StringRef Buffer) const {
+Expected<std::string>
+BenchmarkRunner::writeObjectFile(StringRef Buffer, StringRef FileName) const {
   int ResultFD = 0;
-  SmallString<256> ResultPath;
+  SmallString<256> ResultPath = FileName;
   if (Error E = errorCodeToError(
-          sys::fs::createTemporaryFile("snippet", "o", ResultFD, ResultPath)))
+          FileName.empty() ? sys::fs::createTemporaryFile("snippet", "o",
+                                                          ResultFD, ResultPath)
+                           : sys::fs::openFileForReadWrite(
+                                 FileName, ResultFD, sys::fs::CD_CreateAlways,
+                                 sys::fs::OF_None)))
     return std::move(E);
   raw_fd_ostream OFS(ResultFD, true /*ShouldClose*/);
   OFS.write(Buffer.data(), Buffer.size());
   OFS.flush();
   return std::string(ResultPath.str());
 }
 
 BenchmarkRunner::FunctionExecutor::~FunctionExecutor() {}
 
 } // namespace exegesis
 } // namespace llvm

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

MCPU("mcpu",
          cl::value_desc("cpu-name"), cl::cat(Options), cl::init("native"));
 
 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 (default = false)"),
     cl::cat(BenchmarkOptions), cl::init(false));
 
+static cl::opt<std::string> DumpFileName(
+    "dump-file-name",
+    cl::desc("sets dump file name (requires --dump-object-to-disk)"),
+    cl::cat(BenchmarkOptions));
+
 static ExitOnError ExitOnErr("llvm-exegesis error: ");
 
 // Helper function that logs the error(s) and exits.
 template <typename... ArgTs> static void ExitWithError(ArgTs &&... Args) {
   ExitOnErr(make_error<Failure>(std::forward<ArgTs>(Args)...));
 }
 
 // Check Err. If it's in a failure state log the file error(s) and exit.
static void runBenchmarkConfigurations(
   for (const BenchmarkCode &Conf : Configurations) {
     ProgressMeter<>::ProgressMeterStep MeterStep(Meter ? &*Meter : nullptr);
     SmallVector<Benchmark, 2> AllResults;
 
     for (const std::unique_ptr<const SnippetRepetitor> &Repetitor :
          Repetitors) {
       auto RC = ExitOnErr(Runner.getRunnableConfiguration(
           Conf, NumRepetitions, LoopBodySize, *Repetitor));
-      AllResults.emplace_back(
-          ExitOnErr(Runner.runConfiguration(std::move(RC), DumpObjectToDisk)));
+      AllResults.emplace_back(ExitOnErr(Runner.runConfiguration(
+          std::move(RC), DumpObjectToDisk, DumpFileName)));
     }
     Benchmark &Result = AllResults.front();
 
     // If any of our measurements failed, pretend they all have failed.
     if (AllResults.size() > 1 &&
         any_of(AllResults, [](const Benchmark &R) {
           return R.Measurements.empty();
         }))