[InstrProf][Temporal] Add weight field to traces

[ellis]

Summary

As discussed in [0], add a weight field to temporal profiling traces found in profiles. This allows users to use the --weighted-input= flag in the llvm-profdata merge command to weight traces from different scenarios differently.

Note that this is a breaking change, but since [1] landed very recently and there is no way to "use" this trace data, there should be no users of this feature. We believe it is acceptable to land this change without bumping the profile format version.

[0] https://reviews.llvm.org/D147812#4259507
[1] https://reviews.llvm.org/D147287

[snehasish]

llvm/docs/CommandGuide/llvm-profdata.rst

203

typo: use

208

nit: Should we rename this flag to --temporal-profile-max-trace-length to be consistent with the naming of the others with the same prefix? I missed this in the prior review.

213

I think in this usage model only a single trace with unique weight can be merged at a time. Can we use existing -weighted-input flag in llvm-profdata to implement this?
https://llvm.org/docs/CommandGuide/llvm-profdata.html#cmdoption-llvm-profdata-merge-weighted-input

llvm/include/llvm/ProfileData/InstrProfReader.h

403–404

nit: Prefer llvm::ArrayRef<TemporalProfTraceTy> instead of a constant reference?

llvm/tools/llvm-profdata/llvm-profdata.cpp

1326

You should be able to extract the weight for an input (in this case, a raw temporal prof trace) from this instead of adding a separate flag. Also see the comment above.

[ellis]

llvm/docs/CommandGuide/llvm-profdata.rst

208

I think of this as "max-X-length" where X is "temporal-profile-trace". I'm ok with either, so let me know if you have a strong opinion.

213

This simplifies a few things. Thanks for the suggestion!

llvm/include/llvm/ProfileData/InstrProfReader.h

403–404

I actually realized I should remove the const and make the traces in addTemporalProfileTraces() also a reference to avoid a copy. Thanks for pointing this out!

[ellis]

Remove --temporal-profile-trace-weight flag

[snehasish]

lgtm

llvm/docs/CommandGuide/llvm-profdata.rst

208

I think moving "max" after the "temporal-profile-trace" (or even "temporal-profile") prefix does not change the meaning, so having a consistent prefix for the options for this feature would be nice in my opinion.

llvm/lib/ProfileData/InstrProfWriter.cpp

314

If you use llvm::ArrayRef instead of SmallVectorImpl& then in the unit tests you can avoid having to create SmallVector objects which are then passed to this function. You can replace them with initializer lists and simplify the code a little bit.

SmallVector Traces1({FooTrace}), Traces2({BarTrace});
Writer.addTemporalProfileTraces(Traces1, 1);
Writer2.addTemporalProfileTraces(Traces2, 1);

becomes

Writer.addTemporalProfileTraces({FooTrace}, 1);
Writer2.addTemporalProfileTraces({BarTrace}, 1);

[ellis]

Rename flag to -temporal-profile-max-trace-length

llvm/lib/ProfileData/InstrProfWriter.cpp

314

I can't use ArrayRef because I'm modifying SrcTraces by moving traces from it to the destination writer. MutableArrayRef causes subtle bugs in the unit tests when I make the above change because it clears FooTrace and BarTrace. I think I could use OwningArrayRef but I think this would lead to more copying than is necessary.

[snehasish]

llvm/lib/ProfileData/InstrProfWriter.cpp

314

Ah sorry for the misleading comment then, I should have read the source more closely.

[ellis]

llvm/unittests/ProfileData/InstrProfTest.cpp

252

This broke some builds because of compiler warnings, but I believe it should be fixed by https://reviews.llvm.org/D148259.

https://lab.llvm.org/buildbot/#/builders/57/builds/26047

/home/buildbots/docker-RHEL84-buildbot/SetupBot/worker_env/ppc64le-clang-rhel-test/clang-ppc64le-rhel/llvm-project/llvm/unittests/ProfileData/InstrProfTest.cpp:252:3: error: 'SmallVector' may not intend to support class template argument deduction [-Werror,-Wctad-maybe-unsupported]
  SmallVector Traces = {LargeTrace, SmallTrace};
  ^
/home/buildbots/docker-RHEL84-buildbot/SetupBot/worker_env/ppc64le-clang-rhel-test/clang-ppc64le-rhel/llvm-project/llvm/include/llvm/ADT/SmallVector.h:1199:22: note: add a deduction guide to suppress this warning
class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,

compiler-rt/test/profile/instrprof-timestamp.c

 // RUN: rm -f %t.profdata
 // RUN: %clang_pgogen -o %t -mllvm -pgo-temporal-instrumentation %s
 // RUN: env LLVM_PROFILE_FILE=%t.0.profraw %run %t n
 // RUN: env LLVM_PROFILE_FILE=%t.1.profraw %run %t y
-// RUN: llvm-profdata merge -o %t.profdata %t.0.profraw %t.1.profraw
+// RUN: llvm-profdata merge -o %t.profdata %t.0.profraw --weighted-input=5,%t.1.profraw
 // RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --implicit-check-not=unused
 
 // RUN: rm -f %t.profdata
 // RUN: %clang_pgogen -o %t -mllvm -pgo-temporal-instrumentation -mllvm -pgo-block-coverage %s
 // RUN: env LLVM_PROFILE_FILE=%t.0.profraw %run %t n
 // RUN: env LLVM_PROFILE_FILE=%t.1.profraw %run %t y
-// RUN: llvm-profdata merge -o %t.profdata %t.0.profraw %t.1.profraw
+// RUN: llvm-profdata merge -o %t.profdata %t.0.profraw --weighted-input=5,%t.1.profraw
 // RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --implicit-check-not=unused
 
 extern void exit(int);
 extern void __llvm_profile_reset_counters();
 
 void a() {}
 void b() {}
 void unused() { exit(1); }
if (*argv[1] == 'y')
     __llvm_profile_reset_counters();
   a();
   c();
   b();
   return 0;
 }
 
 // CHECK: Temporal Profile Traces (samples=2 seen=2):
-// CHECK:   Temporal Profile Trace 0 (count=4):
+// CHECK:   Temporal Profile Trace 0 (weight=1 count=4):
 // CHECK:     main
 // CHECK:     a
 // CHECK:     b
 // CHECK:     c
-// CHECK:   Temporal Profile Trace 1 (count=3):
+// CHECK:   Temporal Profile Trace 1 (weight=5 count=3):
 // CHECK:     a
 // CHECK:     c
 // CHECK:     b

llvm/docs/CommandGuide/llvm-profdata.rst

  profile.
 
 .. option:: --debug-info=<path>
 
  Specify the executable or ``.dSYM`` that contains debug info for the raw profile.
  When ``-debug-info-correlate`` was used for instrumentation, use this option
  to correlate the raw profile.
 
+.. option:: --temporal-profile-trace-reservoir-size
+
+ The maximum number of temporal profile traces to be stored in the output
+ profile. If more traces are added, we will use reservoir sampling to select
+ which traces to keep. Note that changing this value between different merge
+ invocations on the same indexed profile could result in sample bias. The
+ default value is 100.
+
+.. option:: --temporal-profile-max-trace-length
+
+ The maximum number of functions in a single temporal profile trace. Longer
+ traces will be truncated. The default value is 1000.
 
 EXAMPLES
 ^^^^^^^^
 Basic Usage
 +++++++++++
 Merge three profiles:
 
 ::
 
     llvm-profdata merge foo.profdata bar.profdata baz.profdata -output merged.profdata

llvm/include/llvm/ProfileData/InstrProf.h

enum class instrprof_error {
   compress_failed,
   uncompress_failed,
   empty_raw_profile,
   zlib_unavailable
 };
 
 /// An ordered list of functions identified by their NameRef found in
 /// INSTR_PROF_DATA
-using TemporalProfTraceTy = std::vector<uint64_t>;
+struct TemporalProfTraceTy {
+  uint64_t Weight = 1;
+  std::vector<uint64_t> FunctionNameRefs;
+};
 
 inline std::error_code make_error_code(instrprof_error E) {
   return std::error_code(static_cast<int>(E), instrprof_category());
 }
 
 class InstrProfError : public ErrorInfo<InstrProfError> {
 public:
   InstrProfError(instrprof_error Err, const Twine &ErrStr = Twine())

llvm/include/llvm/ProfileData/InstrProfReader.h

public:
   static Expected<std::unique_ptr<InstrProfReader>>
   create(const Twine &Path, vfs::FileSystem &FS,
          const InstrProfCorrelator *Correlator = nullptr);
 
   static Expected<std::unique_ptr<InstrProfReader>>
   create(std::unique_ptr<MemoryBuffer> Buffer,
          const InstrProfCorrelator *Correlator = nullptr);
 
+  /// \param Weight for raw profiles use this as the temporal profile trace
+  ///               weight
   /// \returns a list of temporal profile traces.
-  virtual const SmallVector<TemporalProfTraceTy> &getTemporalProfTraces() {
+  virtual SmallVector<TemporalProfTraceTy> &
+  getTemporalProfTraces(std::optional<uint64_t> Weight = {}) {
+    // For non-raw profiles we ignore the input weight and instead use the
+    // weights already in the traces.
     return TemporalProfTraces;
   }
   /// \returns the total number of temporal profile traces seen.
   uint64_t getTemporalProfTraceStreamSize() {
     return TemporalProfTraceStreamSize;
   }
 };
 
public:
   /// Returns a BitsetEnum describing the attributes of the raw instr profile.
   InstrProfKind getProfileKind() const override;
 
   InstrProfSymtab &getSymtab() override {
     assert(Symtab.get());
     return *Symtab.get();
   }
 
-  const SmallVector<TemporalProfTraceTy> &getTemporalProfTraces() override;
+  SmallVector<TemporalProfTraceTy> &
+  getTemporalProfTraces(std::optional<uint64_t> Weight = {}) override;
 
 private:
   Error createSymtab(InstrProfSymtab &Symtab);
   Error readNextHeader(const char *CurrentPos);
   Error readHeader(const RawInstrProf::Header &Header);
 
   template <class IntT> IntT swap(IntT Int) const {
     return ShouldSwapBytes ? sys::getSwappedBytes(Int) : Int;

llvm/include/llvm/ProfileData/InstrProfWriter.h

public:
   void addRecord(NamedInstrProfRecord &&I, uint64_t Weight,
                  function_ref<void(Error)> Warn);
   void addRecord(NamedInstrProfRecord &&I, function_ref<void(Error)> Warn) {
     addRecord(std::move(I), 1, Warn);
   }
 
   /// Add \p SrcTraces using reservoir sampling where \p SrcStreamSize is the
   /// total number of temporal profiling traces the source has seen.
-  void addTemporalProfileTraces(SmallVector<TemporalProfTraceTy> SrcTraces,
+  void addTemporalProfileTraces(SmallVectorImpl<TemporalProfTraceTy> &SrcTraces,
                                 uint64_t SrcStreamSize);
 
   /// Add a memprof record for a function identified by its \p Id.
   void addMemProfRecord(const GlobalValue::GUID Id,
                         const memprof::IndexedMemProfRecord &Record);
 
   /// Add a memprof frame identified by the hash of the contents of the frame in
   /// \p FrameId.

llvm/lib/ProfileData/InstrProfReader.cpp

while (Line->startswith(":")) {
     ++Line;
   }
   return success();
 }
 
 /// Temporal profile trace data is stored in the header immediately after
 /// ":temporal_prof_traces". The first integer is the number of traces, the
 /// second integer is the stream size, then the following lines are the actual
-/// traces which consist of a comma separated list of function names.
+/// traces which consist of a weight and a comma separated list of function
+/// names.
 Error TextInstrProfReader::readTemporalProfTraceData() {
   if ((++Line).is_at_end())
     return error(instrprof_error::eof);
 
   uint32_t NumTraces;
   if (Line->getAsInteger(0, NumTraces))
     return error(instrprof_error::malformed);
 
   if ((++Line).is_at_end())
     return error(instrprof_error::eof);
 
   if (Line->getAsInteger(0, TemporalProfTraceStreamSize))
     return error(instrprof_error::malformed);
 
   for (uint32_t i = 0; i < NumTraces; i++) {
     if ((++Line).is_at_end())
       return error(instrprof_error::eof);
 
     TemporalProfTraceTy Trace;
+    if (Line->getAsInteger(0, Trace.Weight))
+      return error(instrprof_error::malformed);
+
+    if ((++Line).is_at_end())
+      return error(instrprof_error::eof);
+
     SmallVector<StringRef> FuncNames;
     Line->split(FuncNames, ",", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
     for (auto &FuncName : FuncNames)
-      Trace.push_back(IndexedInstrProf::ComputeHash(FuncName.trim()));
+      Trace.FunctionNameRefs.push_back(
+          IndexedInstrProf::ComputeHash(FuncName.trim()));
     TemporalProfTraces.push_back(std::move(Trace));
   }
   return success();
 }
 
 Error
 TextInstrProfReader::readValueProfileData(InstrProfRecord &Record) {
 

 }
 
 template <class IntPtrT>
 InstrProfKind RawInstrProfReader<IntPtrT>::getProfileKind() const {
   return getProfileKindFromVersion(Version);
 }
 
 template <class IntPtrT>
-const SmallVector<TemporalProfTraceTy> &
-RawInstrProfReader<IntPtrT>::getTemporalProfTraces() {
+SmallVector<TemporalProfTraceTy> &
+RawInstrProfReader<IntPtrT>::getTemporalProfTraces(
+    std::optional<uint64_t> Weight) {
   if (TemporalProfTimestamps.empty()) {
     assert(TemporalProfTraces.empty());
     return TemporalProfTraces;
   }
   // Sort functions by their timestamps to build the trace.
   std::sort(TemporalProfTimestamps.begin(), TemporalProfTimestamps.end());
   TemporalProfTraceTy Trace;
+  if (Weight)
+    Trace.Weight = *Weight;
   for (auto &[TimestampValue, NameRef] : TemporalProfTimestamps)
-    Trace.push_back(NameRef);
+    Trace.FunctionNameRefs.push_back(NameRef);
   TemporalProfTraces = {std::move(Trace)};
   return TemporalProfTraces;
 }
 
 template <class IntPtrT>
 bool RawInstrProfReader<IntPtrT>::hasFormat(const MemoryBuffer &DataBuffer) {
   if (DataBuffer.getBufferSize() < sizeof(uint64_t))
     return false;
if (GET_VERSION(Header->formatVersion()) >= 10 &&
     // Expect at least two 64 bit fields: NumTraces, and TraceStreamSize
     if (Ptr + 2 * sizeof(uint64_t) > PtrEnd)
       return error(instrprof_error::truncated);
     const uint64_t NumTraces =
         support::endian::readNext<uint64_t, little, unaligned>(Ptr);
     TemporalProfTraceStreamSize =
         support::endian::readNext<uint64_t, little, unaligned>(Ptr);
     for (unsigned i = 0; i < NumTraces; i++) {
-      // Expect at least one 64 bit field: NumFunctions
-      if (Ptr + sizeof(uint64_t) > PtrEnd)
+      // Expect at least two 64 bit fields: Weight and NumFunctions
+      if (Ptr + 2 * sizeof(uint64_t) > PtrEnd)
         return error(instrprof_error::truncated);
+      TemporalProfTraceTy Trace;
+      Trace.Weight =
+          support::endian::readNext<uint64_t, little, unaligned>(Ptr);
       const uint64_t NumFunctions =
           support::endian::readNext<uint64_t, little, unaligned>(Ptr);
       // Expect at least NumFunctions 64 bit fields
       if (Ptr + NumFunctions * sizeof(uint64_t) > PtrEnd)
         return error(instrprof_error::truncated);
-      TemporalProfTraceTy Trace;
       for (unsigned j = 0; j < NumFunctions; j++) {
         const uint64_t NameRef =
             support::endian::readNext<uint64_t, little, unaligned>(Ptr);
-        Trace.push_back(NameRef);
+        Trace.FunctionNameRefs.push_back(NameRef);
       }
       TemporalProfTraces.push_back(std::move(Trace));
     }
   }
 
   // Load the remapping table now if requested.
   if (RemappingBuffer) {
     Remapper =

llvm/lib/ProfileData/InstrProfWriter.cpp

bool InstrProfWriter::addMemProfFrame(const memprof::FrameId Id,
   return true;
 }
 
 void InstrProfWriter::addBinaryIds(ArrayRef<llvm::object::BuildID> BIs) {
   llvm::append_range(BinaryIds, BIs);
 }
 
 void InstrProfWriter::addTemporalProfileTrace(TemporalProfTraceTy Trace) {
-  if (Trace.size() > MaxTemporalProfTraceLength)
-    Trace.resize(MaxTemporalProfTraceLength);
-  if (Trace.empty())
+  if (Trace.FunctionNameRefs.size() > MaxTemporalProfTraceLength)
+    Trace.FunctionNameRefs.resize(MaxTemporalProfTraceLength);
+  if (Trace.FunctionNameRefs.empty())
     return;
 
   if (TemporalProfTraceStreamSize < TemporalProfTraceReservoirSize) {
     // Simply append the trace if we have not yet hit our reservoir size limit.
     TemporalProfTraces.push_back(std::move(Trace));
   } else {
     // Otherwise, replace a random trace in the stream.
     std::uniform_int_distribution<uint64_t> Distribution(
         0, TemporalProfTraceStreamSize);
     uint64_t RandomIndex = Distribution(RNG);
     if (RandomIndex < TemporalProfTraces.size())
       TemporalProfTraces[RandomIndex] = std::move(Trace);
   }
   ++TemporalProfTraceStreamSize;
 }
 
 void InstrProfWriter::addTemporalProfileTraces(
-    SmallVector<TemporalProfTraceTy> SrcTraces, uint64_t SrcStreamSize) {
+    SmallVectorImpl<TemporalProfTraceTy> &SrcTraces, uint64_t SrcStreamSize) {
   // Assume that the source has the same reservoir size as the destination to
   // avoid needing to record it in the indexed profile format.
   bool IsDestSampled =
       (TemporalProfTraceStreamSize > TemporalProfTraceReservoirSize);
   bool IsSrcSampled = (SrcStreamSize > TemporalProfTraceReservoirSize);
   if (!IsDestSampled && IsSrcSampled) {
     // If one of the traces are sampled, ensure that it belongs to Dest.
     std::swap(TemporalProfTraces, SrcTraces);
void InstrProfWriter::mergeRecordsFromWriter(InstrProfWriter &&IPW,
   for (auto &I : IPW.FunctionData)
     for (auto &Func : I.getValue())
       addRecord(I.getKey(), Func.first, std::move(Func.second), 1, Warn);
 
   BinaryIds.reserve(BinaryIds.size() + IPW.BinaryIds.size());
   for (auto &I : IPW.BinaryIds)
     addBinaryIds(I);
 
-  addTemporalProfileTraces(std::move(IPW.TemporalProfTraces),
+  addTemporalProfileTraces(IPW.TemporalProfTraces,
                            IPW.TemporalProfTraceStreamSize);
 
   MemProfFrameData.reserve(IPW.MemProfFrameData.size());
   for (auto &I : IPW.MemProfFrameData) {
     // If we weren't able to add the frame mappings then it doesn't make sense
     // to try to merge the records from this profile.
     if (!addMemProfFrame(I.first, I.second, Warn))
       return;
Error InstrProfWriter::writeImpl(ProfOStream &OS) {
   }
 
   uint64_t TemporalProfTracesSectionStart = 0;
   if (static_cast<bool>(ProfileKind & InstrProfKind::TemporalProfile)) {
     TemporalProfTracesSectionStart = OS.tell();
     OS.write(TemporalProfTraces.size());
     OS.write(TemporalProfTraceStreamSize);
     for (auto &Trace : TemporalProfTraces) {
-      OS.write(Trace.size());
-      for (auto &NameRef : Trace)
+      OS.write(Trace.Weight);
+      OS.write(Trace.FunctionNameRefs.size());
+      for (auto &NameRef : Trace.FunctionNameRefs)
         OS.write(NameRef);
     }
   }
 
   // Allocate space for data to be serialized out.
   std::unique_ptr<IndexedInstrProf::Summary> TheSummary =
       IndexedInstrProf::allocSummary(SummarySize);
   // Compute the Summary and copy the data to the data

 
 void InstrProfWriter::writeTextTemporalProfTraceData(raw_fd_ostream &OS,
                                                      InstrProfSymtab &Symtab) {
   OS << ":temporal_prof_traces\n";
   OS << "# Num Temporal Profile Traces:\n" << TemporalProfTraces.size() << "\n";
   OS << "# Temporal Profile Trace Stream Size:\n"
      << TemporalProfTraceStreamSize << "\n";
   for (auto &Trace : TemporalProfTraces) {
-    for (auto &NameRef : Trace)
+    OS << "# Weight:\n" << Trace.Weight << "\n";
+    for (auto &NameRef : Trace.FunctionNameRefs)
       OS << Symtab.getFuncName(NameRef) << ",";
     OS << "\n";
   }
   OS << "\n";
 }

llvm/test/tools/llvm-profdata/merge-traces.proftext

 # RUN: llvm-profdata merge --temporal-profile-trace-reservoir-size=2 %s -o %t.profdata
 # RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --check-prefixes=SAMPLE1,SEEN1
 # RUN: llvm-profdata merge --temporal-profile-trace-reservoir-size=2 %s %t.profdata -o %t.profdata
 # RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --check-prefixes=SAMPLE2,SEEN2
 # RUN: llvm-profdata merge --temporal-profile-trace-reservoir-size=2 %s %t.profdata -o %t.profdata
 # RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --check-prefixes=SAMPLE2,SEEN3
 # RUN: llvm-profdata merge --temporal-profile-trace-reservoir-size=2 %s %t.profdata -o %t.profdata
 # RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --check-prefixes=SAMPLE2,SEEN4
 
 # SEEN1: Temporal Profile Traces (samples=1 seen=1):
 # SEEN2: Temporal Profile Traces (samples=2 seen=2):
 # SEEN3: Temporal Profile Traces (samples=2 seen=3):
 # SEEN4: Temporal Profile Traces (samples=2 seen=4):
-# SAMPLE1: Temporal Profile Trace 0 (count=3):
+# SAMPLE1: Temporal Profile Trace 0 (weight=1 count=3):
 # SAMPLE1:   a
 # SAMPLE1:   b
 # SAMPLE1:   c
-# SAMPLE2: Temporal Profile Trace 1 (count=3):
+# SAMPLE2: Temporal Profile Trace 1 (weight=1 count=3):
 # SAMPLE2:   a
 # SAMPLE2:   b
 # SAMPLE2:   c
 
 # Header
 :ir
 :temporal_prof_traces
 # Num Traces
 1
 # Trace Stream Size:
 1
+# Weight
+1
 a, b, c
 
 
 a
 # Func Hash:
 0x1234
 # Num Counters:
 1

llvm/test/tools/llvm-profdata/read-traces.proftext

 # RUN: llvm-profdata merge -text %s -o %t.1.proftext
 # RUN: llvm-profdata merge -binary %t.1.proftext -o %t.2.profdata
 # RUN: llvm-profdata merge -text %t.2.profdata -o %t.3.proftext
 # RUN: diff %t.1.proftext %t.3.proftext
 
 # RUN: llvm-profdata show --temporal-profile-traces %t.1.proftext | FileCheck %s
 
 # CHECK: Temporal Profile Traces (samples=3 seen=3):
-# CHECK: Temporal Profile Trace 0 (count=3):
+# CHECK: Temporal Profile Trace 0 (weight=1 count=3):
 # CHECK:   foo
 # CHECK:   bar
 # CHECK:   goo
-# CHECK: Temporal Profile Trace 1 (count=3):
+# CHECK: Temporal Profile Trace 1 (weight=3 count=3):
 # CHECK:   foo
 # CHECK:   goo
 # CHECK:   bar
-# CHECK: Temporal Profile Trace 2 (count=1):
+# CHECK: Temporal Profile Trace 2 (weight=1 count=1):
 # CHECK:   goo
 
 # Header
 :ir
 :temporal_prof_traces
 # Num Traces:
 3
 # Trace Stream Size:
 3
+# Weight
+1
 foo, bar, goo
+# Weight
+3
 foo,goo,bar,
+# Weight
+1
 goo
 
 foo
 # Func Hash:
 0x1234
 # Num Counters:
 1
 # Counter Values:

llvm/test/tools/llvm-profdata/trace-limit.proftext

-# RUN: llvm-profdata merge --max-temporal-profile-trace-length=0 %s -o %t.profdata
+# RUN: llvm-profdata merge --temporal-profile-max-trace-length=0 %s -o %t.profdata
 # RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --check-prefix=NONE
 
-# RUN: llvm-profdata merge --max-temporal-profile-trace-length=2 %s -o %t.profdata
+# RUN: llvm-profdata merge --temporal-profile-max-trace-length=2 %s -o %t.profdata
 # RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --check-prefixes=CHECK,SOME
 
-# RUN: llvm-profdata merge --max-temporal-profile-trace-length=1000 %s -o %t.profdata
+# RUN: llvm-profdata merge --temporal-profile-max-trace-length=1000 %s -o %t.profdata
 # RUN: llvm-profdata show --temporal-profile-traces %t.profdata | FileCheck %s --check-prefixes=CHECK,ALL
 
 # NONE: Temporal Profile Traces (samples=0 seen=0):
 # CHECK: Temporal Profile Traces (samples=1 seen=1):
-# SOME:   Trace 0 (count=2):
-# ALL:    Trace 0 (count=3):
+# SOME:   Trace 0 (weight=1 count=2):
+# ALL:    Trace 0 (weight=1 count=3):
 
 # Header
 :ir
 :temporal_prof_traces
 # Num Traces
 1
 # Trace Stream Size:
 1
+# Weight
+1
 a, b, c
 
 
 a
 # Func Hash:
 0x1234
 # Num Counters:
 1

llvm/tools/llvm-profdata/llvm-profdata.cpp

WC->Writer.addRecord(std::move(I), Input.Weight, [&](Error E) {
       std::unique_lock<std::mutex> ErrGuard{WC->ErrLock};
       bool firstTime = WC->WriterErrorCodes.insert(IPE).second;
       handleMergeWriterError(make_error<InstrProfError>(IPE), Input.Filename,
                              FuncName, firstTime);
     });
   }
 
   if (Reader->hasTemporalProfile()) {
-    auto &Traces = Reader->getTemporalProfTraces();
+    auto &Traces = Reader->getTemporalProfTraces(Input.Weight);
     if (!Traces.empty())
       WC->Writer.addTemporalProfileTraces(
           Traces, Reader->getTemporalProfTraceStreamSize());
   }
   if (Reader->hasError()) {
     if (Error E = Reader->getError())
       WC->Errors.emplace_back(std::move(E), Filename);
   }
cl::opt<bool> DropProfileSymbolList(
                "(only meaningful for -sample)"));
   // WARNING: This reservoir size value is propagated to any input indexed
   // profiles for simplicity. Changing this value between invocations could
   // result in sample bias.
   cl::opt<uint64_t> TemporalProfTraceReservoirSize(
       "temporal-profile-trace-reservoir-size", cl::init(100),
       cl::desc("The maximum number of stored temporal profile traces (default: "
                "100)"));
-  cl::opt<uint64_t> MaxTemporalProfTraceLength(
-      "max-temporal-profile-trace-length", cl::init(10000),
+  cl::opt<uint64_t> TemporalProfMaxTraceLength(
+      "temporal-profile-max-trace-length", cl::init(10000),
       cl::desc("The maximum length of a single temporal profile trace "
                "(default: 10000)"));
 
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
 
   WeightedFileVector WeightedInputs;
   for (StringRef Filename : InputFilenames)
     addWeightedInput(WeightedInputs, {std::string(Filename), 1});
if (!SupplInstrWithSample.empty()) {
 
     supplementInstrProfile(WeightedInputs, SupplInstrWithSample, OutputFilename,
                            OutputFormat, OutputSparse, SupplMinSizeThreshold,
                            ZeroCounterThreshold, InstrProfColdThreshold);
     return 0;
   }
 
   if (ProfileKind == instr)
     mergeInstrProfile(WeightedInputs, DebugInfoFilename, Remapper.get(),
                       OutputFilename, OutputFormat,
                       TemporalProfTraceReservoirSize,
-                      MaxTemporalProfTraceLength, OutputSparse, NumThreads,
+                      TemporalProfMaxTraceLength, OutputSparse, NumThreads,
                       FailureMode, ProfiledBinary);
   else
     mergeSampleProfile(WeightedInputs, Remapper.get(), OutputFilename,
                        OutputFormat, ProfileSymbolListFile, CompressAllSections,
                        UseMD5, GenPartialProfile, ProfileLayout,
                        SampleMergeColdContext, SampleTrimColdContext,
                        SampleColdContextFrameDepth, FailureMode,
                        DropProfileSymbolList, OutputSizeLimit);
static int showInstrProfile(
   if (ShowProfileVersion)
     OS << "Profile version: " << Reader->getVersion() << "\n";
 
   if (ShowTemporalProfTraces) {
     auto &Traces = Reader->getTemporalProfTraces();
     OS << "Temporal Profile Traces (samples=" << Traces.size()
        << " seen=" << Reader->getTemporalProfTraceStreamSize() << "):\n";
     for (unsigned i = 0; i < Traces.size(); i++) {
-      OS << "  Temporal Profile Trace " << i << " (count=" << Traces[i].size()
-         << "):\n";
-      for (auto &NameRef : Traces[i])
+      OS << "  Temporal Profile Trace " << i << " (weight=" << Traces[i].Weight
+         << " count=" << Traces[i].FunctionNameRefs.size() << "):\n";
+      for (auto &NameRef : Traces[i].FunctionNameRefs)
         OS << "    " << Reader->getSymtab().getFuncName(NameRef) << "\n";
     }
   }
 
   return 0;
 }
 
 static void showSectionInfo(sampleprof::SampleProfileReader *Reader,

llvm/unittests/ProfileData/InstrProfTest.cpp

handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
     Found = IPE.get();
     FoundMsg = IPE.message();
   });
   if (Expected == Found)
     return ::testing::AssertionSuccess();
   return ::testing::AssertionFailure() << "error: " << FoundMsg << "\n";
 }
 
+namespace llvm {
+bool operator==(const TemporalProfTraceTy &lhs,
+                const TemporalProfTraceTy &rhs) {
+  return lhs.Weight == rhs.Weight &&
+         lhs.FunctionNameRefs == rhs.FunctionNameRefs;
+}
+} // end namespace llvm
+
 namespace {
 
 struct InstrProfTest : ::testing::Test {
   InstrProfWriter Writer;
   std::unique_ptr<IndexedInstrProfReader> Reader;
 
   void SetUp() override { Writer.setOutputSparse(false); }
 

 
 TEST_F(InstrProfTest, test_merge_temporal_prof_traces_truncated) {
   uint64_t ReservoirSize = 10;
   uint64_t MaxTraceLength = 2;
   InstrProfWriter Writer(/*Sparse=*/false, ReservoirSize, MaxTraceLength);
   ASSERT_THAT_ERROR(Writer.mergeProfileKind(InstrProfKind::TemporalProfile),
                     Succeeded());
 
-  auto LargeTrace = {IndexedInstrProf::ComputeHash("foo"),
+  TemporalProfTraceTy LargeTrace, SmallTrace;
+  LargeTrace.FunctionNameRefs = {IndexedInstrProf::ComputeHash("foo"),
                                  IndexedInstrProf::ComputeHash("bar"),
                                  IndexedInstrProf::ComputeHash("goo")};
-  auto SmallTrace = {IndexedInstrProf::ComputeHash("foo"),
+  SmallTrace.FunctionNameRefs = {IndexedInstrProf::ComputeHash("foo"),
                                  IndexedInstrProf::ComputeHash("bar")};
 
-  Writer.addTemporalProfileTraces({LargeTrace, SmallTrace}, 2);
+  SmallVector Traces = {LargeTrace, SmallTrace};
+  Writer.addTemporalProfileTraces(Traces, 2);
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   ASSERT_TRUE(Reader->hasTemporalProfile());
   EXPECT_EQ(Reader->getTemporalProfTraceStreamSize(), 2U);
   EXPECT_THAT(Reader->getTemporalProfTraces(),
               UnorderedElementsAre(SmallTrace, SmallTrace));
 }
 
 TEST_F(InstrProfTest, test_merge_traces_from_writer) {
   uint64_t ReservoirSize = 10;
   uint64_t MaxTraceLength = 10;
   InstrProfWriter Writer(/*Sparse=*/false, ReservoirSize, MaxTraceLength);
   InstrProfWriter Writer2(/*Sparse=*/false, ReservoirSize, MaxTraceLength);
   ASSERT_THAT_ERROR(Writer.mergeProfileKind(InstrProfKind::TemporalProfile),
                     Succeeded());
   ASSERT_THAT_ERROR(Writer2.mergeProfileKind(InstrProfKind::TemporalProfile),
                     Succeeded());
 
-  auto FooTrace = {IndexedInstrProf::ComputeHash("foo")};
-  auto BarTrace = {IndexedInstrProf::ComputeHash("bar")};
-
-  Writer.addTemporalProfileTraces({FooTrace}, 1);
-  Writer2.addTemporalProfileTraces({BarTrace}, 1);
+  TemporalProfTraceTy FooTrace, BarTrace;
+  FooTrace.FunctionNameRefs = {IndexedInstrProf::ComputeHash("foo")};
+  BarTrace.FunctionNameRefs = {IndexedInstrProf::ComputeHash("bar")};
+
+  SmallVector Traces1({FooTrace}), Traces2({BarTrace});
+  Writer.addTemporalProfileTraces(Traces1, 1);
+  Writer2.addTemporalProfileTraces(Traces2, 1);
   Writer.mergeRecordsFromWriter(std::move(Writer2), Err);
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   ASSERT_TRUE(Reader->hasTemporalProfile());
   EXPECT_EQ(Reader->getTemporalProfTraceStreamSize(), 2U);
   EXPECT_THAT(Reader->getTemporalProfTraces(),
               UnorderedElementsAre(FooTrace, BarTrace));
 }
 
 TEST_F(InstrProfTest, test_merge_traces_sampled) {
   uint64_t ReservoirSize = 3;
   uint64_t MaxTraceLength = 10;
   InstrProfWriter Writer(/*Sparse=*/false, ReservoirSize, MaxTraceLength);
   ASSERT_THAT_ERROR(Writer.mergeProfileKind(InstrProfKind::TemporalProfile),
                     Succeeded());
 
-  auto FooTrace = {IndexedInstrProf::ComputeHash("foo")};
-  auto BarTrace = {IndexedInstrProf::ComputeHash("bar")};
-  auto GooTrace = {IndexedInstrProf::ComputeHash("Goo")};
+  TemporalProfTraceTy FooTrace, BarTrace, GooTrace;
+  FooTrace.FunctionNameRefs = {IndexedInstrProf::ComputeHash("foo")};
+  BarTrace.FunctionNameRefs = {IndexedInstrProf::ComputeHash("bar")};
+  GooTrace.FunctionNameRefs = {IndexedInstrProf::ComputeHash("Goo")};
 
   // Add some sampled traces
-  Writer.addTemporalProfileTraces({FooTrace, BarTrace, GooTrace}, 5);
+  SmallVector SampledTraces = {FooTrace, BarTrace, GooTrace};
+  Writer.addTemporalProfileTraces(SampledTraces, 5);
   // Add some unsampled traces
-  Writer.addTemporalProfileTraces({BarTrace, GooTrace}, 2);
-  Writer.addTemporalProfileTraces({FooTrace}, 1);
+  SmallVector UnsampledTraces = {BarTrace, GooTrace};
+  Writer.addTemporalProfileTraces(UnsampledTraces, 2);
+  UnsampledTraces = {FooTrace};
+  Writer.addTemporalProfileTraces(UnsampledTraces, 1);
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   ASSERT_TRUE(Reader->hasTemporalProfile());
   EXPECT_EQ(Reader->getTemporalProfTraceStreamSize(), 8U);
   // Check that we have a subset of all the traces we added
   EXPECT_THAT(Reader->getTemporalProfTraces(), SizeIs(ReservoirSize));