[llvm-exegesis] Create snippet object files with predictable names

[kpdev42]

Summary

To make it possible to dump multiple objects during a single run, the
output files are named /path/to/snippet-OPCODE-REPETITOR.o with constant
parts omitted (for example, if dumping a single object file, its name is
exactly the value of --dump-object-to-disk option).

In dbc76ef791, the call to writeObjectFile() function was moved to
runConfiguration() because the latter is inherently serial to make the
"Check generated assembly with: ..." lines readable. Because now file
names are predictable, this message is not needed anymore, so the
writeObjectFile() function can be called at any suitable place.

~~

Huawei RRI, OS Lab

[kpdev42]

Update patch

[courbet]

llvm/docs/CommandGuide/llvm-exegesis.rst

362–364

Why not always add the OPCODE and REPETITOR parts ? Consistency is good :)

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

27–41

Don't roll your own code for this - use llvm/include/llvm/Support/Path.h.

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

365

Let's remove the special case and be consistent

llvm/docs/CommandGuide/llvm-exegesis.rst

  (`-mcpu=help` for details)
 
 .. option:: --analysis-override-benchmark-triple-and-cpu
 
   By default, llvm-exegesis will analyze the benchmarks for the triple/CPU they
   were measured for, but if you want to analyze them for some other combination
   (specified via `-mtriple`/`-mcpu`), you can pass this flag.
 
-.. option:: --dump-object-to-disk=true
+.. option:: --dump-object-to-disk=</path/to/file.o>
 
- If set,  llvm-exegesis will dump the generated code to a temporary file to
- enable code inspection. Disabled by default.
+ If set, llvm-exegesis will dump the generated code to file. If multiple files
+ are to be written, they will have names /path/to/file-OPCODE-REPETITOR.o with
+ `-OPCODE` and `-REPETITOR` parts omitted if always the same.
 
 .. option:: --use-dummy-perf-counters
 
  If set, llvm-exegesis will not read any real performance counters and
  return a dummy value instead. This can be used to ensure a snippet doesn't
  crash when hardware performance counters are unavailable and for
  debugging :program:`llvm-exegesis` itself.
 
 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/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=assemble-measured-code -opcode-name=ADDPSrr -repetition-mode=duplicate -dump-object-to-disk 2>&1 | FileCheck %s --check-prefix=CHECK-ON
-# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=assemble-measured-code -opcode-name=ADDPSrr -repetition-mode=loop      -dump-object-to-disk 2>&1 | FileCheck %s --check-prefix=CHECK-ON
-# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=assemble-measured-code -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=assemble-measured-code -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 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=loop 2>&1 | FileCheck %s --check-prefix=CHECK-OFF
-
-# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency --benchmark-phase=prepare-and-assemble-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-and-assemble-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=prepare-and-assemble-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-and-assemble-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=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=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=%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
+# This test requires -debug-only=... command line option.
+# This test uses "mkdir -p".
+REQUIRES: asserts, system-linux
+
+# Check that nothing is dumped if not requested.
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -opcode-name=ADDPSrr -benchmark-phase=assemble-measured-code 2>&1 \
+RUN: | FileCheck %s --check-prefix=CHECK-OFF
+
+# Check various benchmark phases.
+# An object is never dumped if benchmark phase is below "assemble-measured-code".
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=prepare-snippet -opcode-name=ADDPSrr 2>&1 \
+RUN: | FileCheck %s --check-prefix=CHECK-OFF
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=prepare-and-assemble-snippet -opcode-name=ADDPSrr 2>&1 \
+RUN: | FileCheck %s --check-prefix=CHECK-OFF
+
+# Check generating multiple output names.
+# In the most general case, -dump-object-to-disk=/tmp/snippet.o results in /tmp/snippet-<OPCODE>-<REPETITOR>.o names.
+# If only one OPCODE or only one REPETITOR is dumped, the corresponding infix is omitted.
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=ADDPSrr -repetition-mode=loop 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-ONE
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=ADDPSrr -repetition-mode=duplicate 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-ONE
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=ADDPSrr -repetition-mode=min 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-REPETITORS
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=ADDPSrr,ADDPDrr -repetition-mode=loop 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-OPCODES
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=ADDPSrr,ADDPDrr -repetition-mode=duplicate 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-OPCODES
+
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=ADDPSrr,ADDPDrr -repetition-mode=min 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-OPCODES-REPETITORS
+
+# Check handling of multiple configs per opcode
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.o -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=SETCCr -max-configs-per-opcode=3 -repetition-mode=min 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-CONFIGS-REPETITORS
+
+# Corner case: cannot ensure no dots in %t, so only check the dot-in-directory-name case for now.
+RUN: mkdir -p "%t-snippet.dir"
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t-snippet.dir/file -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=ADDPSrr,ADDPDrr -repetition-mode=loop 2>&1 \
+RUN: | FileCheck %s --implicit-check-not="Output file name is" --check-prefix=CHECK-DOT-IN-DIR
+
+CHECK-OFF-NOT: Output file name is
+
+CHECK-ONE: Output file name is {{.*}}-snippet.o
+
+CHECK-OPCODES: Output file name is {{.*}}-snippet-ADDPSrr.o
+CHECK-OPCODES: Output file name is {{.*}}-snippet-ADDPDrr.o
+
+CHECK-REPETITORS: Output file name is {{.*}}-snippet-dup.o
+CHECK-REPETITORS: Output file name is {{.*}}-snippet-loop.o
+
+CHECK-OPCODES-REPETITORS: Output file name is {{.*}}-snippet-ADDPSrr-dup.o
+CHECK-OPCODES-REPETITORS: Output file name is {{.*}}-snippet-ADDPSrr-loop.o
+CHECK-OPCODES-REPETITORS: Output file name is {{.*}}-snippet-ADDPDrr-dup.o
+CHECK-OPCODES-REPETITORS: Output file name is {{.*}}-snippet-ADDPDrr-loop.o
+
+CHECK-CONFIGS-REPETITORS: Output file name is {{.*}}-snippet-SETCCr-dup.o
+CHECK-CONFIGS-REPETITORS: Output file name is {{.*}}-snippet-SETCCr-loop.o
+CHECK-CONFIGS-REPETITORS: Output file name is {{.*}}-snippet-SETCCr-1-dup.o
+CHECK-CONFIGS-REPETITORS: Output file name is {{.*}}-snippet-SETCCr-1-loop.o
+CHECK-CONFIGS-REPETITORS: Output file name is {{.*}}-snippet-SETCCr-2-dup.o
+CHECK-CONFIGS-REPETITORS: Output file name is {{.*}}-snippet-SETCCr-2-loop.o
+
+CHECK-DOT-IN-DIR: Output file name is {{.*}}-snippet.dir/file-ADDPSrr
+CHECK-DOT-IN-DIR: Output file name is {{.*}}-snippet.dir/file-ADDPDrr
+
+# Check the file contents
+RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -debug-only=exegesis-name-generator \
+RUN:               -dump-object-to-disk=%t.mydmpfile.o -benchmark-phase=assemble-measured-code \
+RUN:               -opcode-name=ADDPSrr -repetition-mode=duplicate 2>&1 \
+RUN: | FileCheck %s --check-prefix=DUMP-FILE-NAME
+RUN: llvm-objdump -d %t.mydmpfile.o | FileCheck %s --check-prefix=ASM
+
+DUMP-FILE-NAME: Output file name is {{.*}}.mydmpfile.o
 ASM: addps
 ASM: retq

llvm/test/tools/llvm-exegesis/X86/uops/uops-HLT.s

-# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=uops --benchmark-phase=assemble-measured-code --dump-object-to-disk=0 --repetition-mode=loop --loop-body-size=1000 --result-aggregation-mode=min --opcode-name=HLT --max-configs-per-opcode=8192 | FileCheck %s
+# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=uops --benchmark-phase=assemble-measured-code --repetition-mode=loop --loop-body-size=1000 --result-aggregation-mode=min --opcode-name=HLT --max-configs-per-opcode=8192 | FileCheck %s
 
 # By definition, loop repetitor can not be used for terminator instructions.
 # Just check that we do not crash.
 
 CHECK:      ---
 CHECK-NEXT: mode: uops
 CHECK-NEXT: key:
 CHECK-NEXT:   instructions:
 CHECK-NEXT:     HLT

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

 struct BenchmarkKey {
   // The LLVM opcode name.
   std::vector<MCInst> Instructions;
   // The initial values of the registers.
   std::vector<RegisterValue> RegisterInitialValues;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
+  // Index of this benchmark configuration among all benchmarks generated
+  // for the same instruction.
+  int Index;
 };
 
 struct BenchmarkMeasure {
   // A helper to create an unscaled BenchmarkMeasure.
   static BenchmarkMeasure Create(std::string Key, double Value) {
     return {Key, Value, Value};
   }
   std::string Key;

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

public:
   public:
     ~RunnableConfiguration() = default;
     RunnableConfiguration(RunnableConfiguration &&) = default;
 
     RunnableConfiguration(const RunnableConfiguration &) = delete;
     RunnableConfiguration &operator=(RunnableConfiguration &&) = delete;
     RunnableConfiguration &operator=(const RunnableConfiguration &) = delete;
 
+    const object::ObjectFile *getObjectFile() const {
+      return ObjectFile.getBinary();
+    }
+
   private:
     RunnableConfiguration() = default;
 
     Benchmark InstrBenchmark;
     object::OwningBinary<object::ObjectFile> ObjectFile;
   };
 
   Expected<RunnableConfiguration>
   getRunnableConfiguration(const BenchmarkCode &Configuration,
                            unsigned NumRepetitions, unsigned LoopUnrollFactor,
                            const SnippetRepetitor &Repetitor) const;
 
-  Expected<Benchmark>
-  runConfiguration(RunnableConfiguration &&RC,
-                   const std::optional<StringRef> &DumpFile) const;
+  Expected<Benchmark> runConfiguration(RunnableConfiguration &&RC) 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,
-                                        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) {
     if (Error E = Snippet.takeError())
       return std::move(E);
     RC.ObjectFile = getObjectFromBuffer(*Snippet);
   }
 
   return std::move(RC);
 }
 
-Expected<Benchmark> BenchmarkRunner::runConfiguration(
-    RunnableConfiguration &&RC,
-    const std::optional<StringRef> &DumpFile) const {
+Expected<Benchmark>
+BenchmarkRunner::runConfiguration(RunnableConfiguration &&RC) const {
   Benchmark &InstrBenchmark = RC.InstrBenchmark;
   object::OwningBinary<object::ObjectFile> &ObjectFile = RC.ObjectFile;
 
-  if (DumpFile && BenchmarkPhaseSelector >
-                      BenchmarkPhaseSelectorE::PrepareAndAssembleSnippet) {
-    auto ObjectFilePath =
-        writeObjectFile(ObjectFile.getBinary()->getData(), *DumpFile);
-    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";
-  }
-
   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);
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, StringRef FileName) const {
-  int ResultFD = 0;
-  SmallString<256> ResultPath = FileName;
-  if (Error E = errorCodeToError(
-          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/lib/CMakeLists.txt

add_llvm_library(LLVMExegesis
   Analysis.cpp
   Assembler.cpp
   BenchmarkResult.cpp
   BenchmarkRunner.cpp
   Clustering.cpp
   CodeTemplate.cpp
   DisassemblerHelper.cpp
   Error.cpp
+  FileNameGenerator.cpp
   LatencyBenchmarkRunner.cpp
   LlvmState.cpp
   MCInstrDescView.cpp
   ParallelSnippetGenerator.cpp
   PerfHelper.cpp
   RegisterAliasing.cpp
   RegisterValue.cpp
   SchedClassResolution.cpp

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

+//===-- FileNameGenerator.h -------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares a helper class for generating distinct stable names for
+/// multiple output files based on a single file name passed on command line.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_EXEGESIS_FILE_NAME_GENERATOR_H
+#define LLVM_TOOLS_LLVM_EXEGESIS_FILE_NAME_GENERATOR_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <string>
+
+namespace llvm {
+namespace exegesis {
+
+/// Helper class to generate stable output file names.
+///
+/// Based on the file name passed via command line option and information
+/// whether multiple opcode and/or repetitor infixes will be requested, this
+/// class generates output file names, so that it is exactly as passed on the
+/// command line in the trivial case (when only a single file is written) and
+/// preventing one output file from overwriting another one dumped during the
+/// same llvm-exegesis run (if multiple files are written).
+class FileNameGenerator {
+public:
+  /// Construct file name generator.
+  ///
+  /// `FileName` is the name passed via command line (empty string means
+  /// output is not requested).
+  /// `HasManyOpcodes` and `HasManyRepetitors` arguments control whether
+  /// output file name should contain corresponding infix.
+  FileNameGenerator(StringRef FileName, bool HasManyOpcodes,
+                    bool HasManyRepetitors)
+      : FileNameGenerator(FileName, {HasManyOpcodes, HasManyRepetitors}) {}
+
+  /// Returns output file name.
+  std::string getFileName(StringRef OpcodeLabel,
+                          StringRef RepetitorLabel) const {
+    return getFileName({OpcodeLabel, RepetitorLabel});
+  }
+
+  /// Returns whether output files should be produced at all.
+  bool isEnabled() const { return IsEnabled; }
+
+private:
+  FileNameGenerator(StringRef FileName, ArrayRef<bool> IsVariableInfix);
+
+  std::string getFileName(ArrayRef<StringRef> Infixes) const;
+
+  bool IsEnabled;
+  std::string FileNamePrefix;
+  std::string FileNameSuffix;
+  SmallVector<bool, 2> IsVariableInfix;
+
+#ifndef NDEBUG
+  // Infixes passed to the first getFileName() call.
+  mutable SmallVector<std::string, 2> FirstInfixes;
+#endif
+};
+
+} // namespace exegesis
+} // namespace llvm
+
+#endif // LLVM_TOOLS_LLVM_EXEGESIS_FILE_NAME_GENERATOR_H

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

+//===-- FileNameGenerator.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 "FileNameGenerator.h"
+
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+#define DEBUG_TYPE "exegesis-name-generator"
+
+namespace llvm {
+namespace exegesis {
+
+FileNameGenerator::FileNameGenerator(StringRef FileName,
+                                     ArrayRef<bool> IsVariableInfix)
+    : IsVariableInfix(IsVariableInfix) {
+  IsEnabled = !FileName.empty();
+  if (!IsEnabled)
+    return;
+
+  size_t DotPosition = FileName.rfind('.');
+  size_t SlashPosition = FileName.find_last_of("/\\");
+
+  if (DotPosition == StringRef::npos ||
+      (SlashPosition != StringRef::npos && DotPosition < SlashPosition)) {
+    // Two corner cases:
+    // 1) "/path/to/file" - no dots at all
+    // 2) "/dir/another_dir.ext/file" - the rightmost dot is in directory name
+    FileNamePrefix = FileName;
+    FileNameSuffix = "";
+  } else {
+    // "/path/to/file.ext" -> "/path/to/file", ".ext"
+    FileNamePrefix = FileName.take_front(DotPosition);
+    FileNameSuffix = FileName.drop_front(DotPosition);
+  }
+}
+
+std::string FileNameGenerator::getFileName(ArrayRef<StringRef> Infixes) const {
+  SmallVector<StringRef, 3> Parts;
+
+  Parts.push_back(FileNamePrefix);
+  for (unsigned I = 0, N = IsVariableInfix.size(); I < N; ++I)
+    if (IsVariableInfix[I])
+      Parts.push_back(Infixes[I]);
+
+#ifndef NDEBUG
+  if (FirstInfixes.empty())
+    FirstInfixes.assign(Infixes.begin(), Infixes.end());
+
+  for (unsigned I = 0, N = IsVariableInfix.size(); I < N; ++I)
+    assert(IsVariableInfix[I] || FirstInfixes[I] == Infixes[I]);
+#endif
+
+  const auto Result = join(Parts, "-") + FileNameSuffix;
+  LLVM_DEBUG(errs() << "Output file name is " << Result << "\n");
+  return Result;
+}
+
+} // namespace exegesis
+} // namespace llvm

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

for (CodeTemplate &CT : Templates) {
             return error;
           BC.Key.Instructions.push_back(IT.build());
         }
         if (CT.ScratchSpacePointerInReg)
           BC.LiveIns.push_back(CT.ScratchSpacePointerInReg);
         BC.Key.RegisterInitialValues =
             computeRegisterInitialValues(CT.Instructions);
         BC.Key.Config = CT.Config;
+        BC.Key.Index = Benchmarks.size();
         Benchmarks.emplace_back(std::move(BC));
         if (Benchmarks.size() >= Opts.MaxConfigsPerOpcode) {
           // We reached the number of  allowed configs and return early.
           return Error::success();
         }
       }
     }
     return Error::success();

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

public:
   virtual BitVector getReservedRegs() const = 0;
 
   // Returns a functor that repeats `Instructions` so that the function executes
   // at least `MinInstructions` instructions.
   virtual FillFunction Repeat(ArrayRef<MCInst> Instructions,
                               unsigned MinInstructions,
                               unsigned LoopBodySize) const = 0;
 
+  virtual std::string getName() const = 0;
+
   explicit SnippetRepetitor(const LLVMState &State) : State(State) {}
 
 protected:
   const LLVMState &State;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif

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

return [Instructions, MinInstructions](FunctionFiller &Filler) {
       Entry.addReturn();
     };
   }
 
   BitVector getReservedRegs() const override {
     // We're using no additional registers.
     return State.getRATC().emptyRegisters();
   }
+
+  std::string getName() const override { return "dup"; }
 };
 
 class LoopSnippetRepetitor : public SnippetRepetitor {
 public:
   explicit LoopSnippetRepetitor(const LLVMState &State)
       : SnippetRepetitor(State),
         LoopCounter(State.getExegesisTarget().getLoopCounterRegister(
             State.getTargetMachine().getTargetTriple())) {}
public:
   }
 
   BitVector getReservedRegs() const override {
     // We're using a single loop counter, but we have to reserve all aliasing
     // registers.
     return State.getRATC().getRegister(LoopCounter).aliasedBits();
   }
 
+  std::string getName() const override { return "loop"; }
+
 private:
   const unsigned LoopCounter;
 };
 
 } // namespace
 
 SnippetRepetitor::~SnippetRepetitor() {}
 

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

 ///
 //===----------------------------------------------------------------------===//
 
 #include "lib/Analysis.h"
 #include "lib/BenchmarkResult.h"
 #include "lib/BenchmarkRunner.h"
 #include "lib/Clustering.h"
 #include "lib/Error.h"
+#include "lib/FileNameGenerator.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"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/TargetParser/Host.h"
 #include <algorithm>
 #include <string>
 
TripleName("mtriple",
                cl::desc("Target triple. See -version for available targets"),
                cl::cat(Options));
 
 static cl::opt<std::string>
     MCPU("mcpu",
          cl::desc("Target a specific cpu type (-mcpu=help for details)"),
          cl::value_desc("cpu-name"), cl::cat(Options), cl::init("native"));
 
-static cl::opt<std::string>
-    DumpObjectToDisk("dump-object-to-disk",
-                     cl::desc("dumps the generated benchmark object to disk "
-                              "and prints a message to access it"),
-                     cl::ValueOptional, cl::cat(BenchmarkOptions));
+static cl::opt<std::string> DumpObjectToDisk(
+    "dump-object-to-disk",
+    cl::desc("Dump generated benchmark object to file (opcode and repetitor "
+             "names are inserted if writing mupliple files)"),
+    cl::cat(BenchmarkOptions), cl::init(""));
 
 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)...));
 }
 
if (Benchmarks.size() >= MaxConfigsPerOpcode)
       break;
     if (auto Err = Generator->generateConfigurations(Variant, Benchmarks,
                                                      ForbiddenRegs))
       return std::move(Err);
   }
   return Benchmarks;
 }
 
+static SmallString<16> formatOpcodeLabel(const MCInstrInfo &MCII,
+                                         const BenchmarkKey &Key) {
+  unsigned Opcode = Key.Instructions[0].getOpcode();
+  const StringRef OpcodeName = MCII.getName(Opcode);
+
+  // It is likely to have only a single configuration per opcode, so handle
+  // Index == 0 differently and return just "OPC" instead of "OPC-0".
+  if (Key.Index == 0)
+    return OpcodeName;
+
+  return formatv("{0}-{1}", OpcodeName, Key.Index);
+}
+
+static void dumpObjectFile(const object::ObjectFile *Obj,
+                           const StringRef DumpFileName) {
+  const StringRef Buffer = Obj->getData();
+  std::error_code EC;
+  raw_fd_ostream OFS(DumpFileName, EC);
+  ExitOnFileError(DumpFileName, errorCodeToError(EC));
+  OFS.write(Buffer.data(), Buffer.size());
+  OFS.flush();
+  ExitOnFileError(DumpFileName, errorCodeToError(OFS.error()));
+}
+
 static void runBenchmarkConfigurations(
     const LLVMState &State, ArrayRef<BenchmarkCode> Configurations,
     ArrayRef<std::unique_ptr<const SnippetRepetitor>> Repetitors,
     const BenchmarkRunner &Runner) {
   assert(!Configurations.empty() && "Don't have any configurations to run.");
+  const MCInstrInfo &MCII = State.getInstrInfo();
   std::optional<raw_fd_ostream> FileOstr;
   if (BenchmarkFile != "-") {
     int ResultFD = 0;
     // Create output file or open existing file and truncate it, once.
     ExitOnErr(errorCodeToError(openFileForWrite(BenchmarkFile, ResultFD,
                                                 sys::fs::CD_CreateAlways,
                                                 sys::fs::OF_TextWithCRLF)));
     FileOstr.emplace(ResultFD, true /*shouldClose*/);
   }
   raw_ostream &Ostr = FileOstr ? *FileOstr : outs();
 
+  bool ManyConfigurations = Configurations.size() > 1;
+  bool ManyRepetitors = Repetitors.size() > 1;
+  FileNameGenerator DumpedObjectName(DumpObjectToDisk, ManyConfigurations,
+                                     ManyRepetitors);
+
   std::optional<ProgressMeter<>> Meter;
   if (BenchmarkMeasurementsPrintProgress)
     Meter.emplace(Configurations.size());
   for (const BenchmarkCode &Conf : Configurations) {
     ProgressMeter<>::ProgressMeterStep MeterStep(Meter ? &*Meter : nullptr);
     SmallVector<Benchmark, 2> AllResults;
 
+    const auto OpcodeLabel = formatOpcodeLabel(MCII, Conf.Key);
+
     for (const std::unique_ptr<const SnippetRepetitor> &Repetitor :
          Repetitors) {
       auto RC = ExitOnErr(Runner.getRunnableConfiguration(
           Conf, NumRepetitions, LoopBodySize, *Repetitor));
-      std::optional<StringRef> DumpFile;
-      if (DumpObjectToDisk.getNumOccurrences())
-        DumpFile = DumpObjectToDisk;
+
+      if (BenchmarkPhaseSelector >=
+              BenchmarkPhaseSelectorE::AssembleMeasuredCode &&
+          DumpedObjectName.isEnabled()) {
+        dumpObjectFile(
+            RC.getObjectFile(),
+            DumpedObjectName.getFileName(OpcodeLabel, Repetitor->getName()));
+      }
+
       AllResults.emplace_back(
-          ExitOnErr(Runner.runConfiguration(std::move(RC), DumpFile)));
+          ExitOnErr(Runner.runConfiguration(std::move(RC))));
     }
     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();
         }))

llvm/unittests/tools/llvm-exegesis/Mips/BenchmarkResultTest.cpp

TEST_F(MipsBenchmarkResultTest, WriteToAndReadFromDisk) {
 
   Benchmark ToDisk;
 
   ToDisk.Key.Instructions.push_back(MCInstBuilder(Mips::XOR)
                                         .addReg(Mips::T0)
                                         .addReg(Mips::T1)
                                         .addReg(Mips::T2));
   ToDisk.Key.Config = "config";
+  ToDisk.Key.Index = 0;
   ToDisk.Key.RegisterInitialValues = {
       RegisterValue{Mips::T1, APInt(8, "123", 10)},
       RegisterValue{Mips::T2, APInt(8, "456", 10)}};
   ToDisk.Mode = Benchmark::Latency;
   ToDisk.CpuName = "cpu_name";
   ToDisk.LLVMTriple = "llvm_triple";
   ToDisk.NumRepetitions = 1;
   ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, 1});

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

TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   Benchmark ToDisk;
 
   ToDisk.Key.Instructions.push_back(MCInstBuilder(X86::XOR32rr)
                                         .addReg(X86::AL)
                                         .addReg(X86::AH)
                                         .addImm(123)
                                         .addDFPImm(bit_cast<uint64_t>(0.5)));
   ToDisk.Key.Config = "config";
+  ToDisk.Key.Index = 0;
   ToDisk.Key.RegisterInitialValues = {
       RegisterValue{X86::AL, APInt(8, "-1", 10)},
       RegisterValue{X86::AH, APInt(8, "123", 10)}};
   ToDisk.Mode = Benchmark::Latency;
   ToDisk.CpuName = "cpu_name";
   ToDisk.LLVMTriple = "llvm_triple";
   ToDisk.NumRepetitions = 1;
   ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, 1});