[llvm-profdata] Add support for weighted merge of profile data

[slingn]

Summary

This change adds support for an optional weight when merging profile data with the llvm-profdata tool.
Weights are specified by adding an option ':<weight>' suffix to the input file names.

Adding support for arbitrary weighting of input profile data allows for relative importance to be placed on the
input data from multiple training runs.

Both sampled and instrumented profiles are supported.

[davidxl]

Thanks -- this is a good functionality.

A high level comment about the command line syntax. I think we can do it without introducing a new option. All that needed for user is to add an optional weight suffix to the input file name such as:

llvm-profdata merge -o outp.profdata input1.data:10 input2.data:5 input3.data

When the :weight suffix is missing, the weight is assumed to be 1.

Note that this will like to simplify the implementation quite a bit -- not special parsing is needed.

[davidxl]

lib/ProfileData/InstrProfWriter.cpp

108 ↗

(On Diff #39836)

value Profile data needs to be weight aware too.

140 ↗

(On Diff #39836)

nit: Multiply ... by Weight.

test/tools/llvm-profdata/weight-sample.test

42 ↗

(On Diff #39836)

No need for such tests if the weight is always attached to the input file.

tools/llvm-profdata/llvm-profdata.cpp

61 ↗

(On Diff #39836)

You can directly fetch the weight from the augmented file name.

69 ↗

(On Diff #39836)

Why doing weight here?

74 ↗

(On Diff #39836)

Pass the weight to addRecord method instead.

[silvas]

In D14547#286382, @davidxl wrote:

Thanks -- this is a good functionality.

A high level comment about the command line syntax. I think we can do it without introducing a new option. All that needed for user is to add an optional weight suffix to the input file name such as:

llvm-profdata merge -o outp.profdata input1.data:10 input2.data:5 input3.data

When the :weight suffix is missing, the weight is assumed to be 1.

Note that this will like to simplify the implementation quite a bit -- not special parsing is needed.

I agree with David here. The suffix approach seems a lot more robust and convenient. The only requirement is being able to assume that : doesn't appear in filenames, which might be a problem on windows, but that can probably be mitigated by checking that it is of the form :<decimal integer> I think.

[silvas]

include/llvm/ProfileData/SampleProf.h

194 ↗

(On Diff #39836)

Why did this suddenly become unaligned with the comment? (I suggest setting up clang-format).

lib/ProfileData/InstrProfWriter.cpp

143 ↗

(On Diff #39836)

Just use a lambda. Or I think you might be able to get away with this which is shorter:

for (auto &Count : Dest.Counts)
  Count *= Weight;

Also, it seems like there are multiple places that the weight comes into play. Can you please ensure there is a Single Point Of Truth for where the weight is applied?

[slingn]

lib/ProfileData/InstrProfWriter.cpp

143 ↗

(On Diff #39836)

I have refactored things in the next patch set.

tools/llvm-profdata/llvm-profdata.cpp

61 ↗

(On Diff #39836)

It's still better in my mind to parse the weight in a separate method since that can be shared between instr and sampled merge - and is a clearer separation of concerns.

69 ↗

(On Diff #39836)

Fixed. Yes - this approach was left over from a previous revision.

[slingn]

Updated for dnovillo, davidxl and silvas feedback.

-Changed to use ':<weight>' file suffix rather than add a --weights=N,M option.
-Refectored so that weights are applied in narrower scope (aka 'Single Point of Truth')

[davidxl]

include/llvm/ProfileData/InstrProf.h

324 ↗

(On Diff #40201)

Why moving this definition in-class? Try to avoid bringing irrelevant changes like this. It makes it harder to compare two versions.

413 ↗

(On Diff #40201)

Moving this function from InstrProfWriter.cpp to here is fine, but can you submit a different patch for that?

include/llvm/Support/MathExtras.h

656 ↗

(On Diff #40201)

Can you submit the saturating math change in a separate patch?

lib/ProfileData/InstrProfWriter.cpp

117 ↗

(On Diff #40201)

Result is not checked here.

120 ↗

(On Diff #40201)

Since you refactored the code with an else branch, you can sink the max function count update and return statement after the the if-then-else. I think this should be done in a separate patch (same one as moving the merge from writer cpp to instrprof.cpp)

tools/llvm-profdata/llvm-profdata.cpp

88 ↗

(On Diff #40201)

There does seem to be a need to exposed the 'scale' method publicly -- it is better to make AddRecord to take an optional weight parameter as the previous version, and let AddRecord's implementation to call private scale method.

138 ↗

(On Diff #40201)

Similarly here merge can take an optional weight parameter.

[slingn]

include/llvm/ProfileData/InstrProf.h

324 ↗

(On Diff #40201)

It looks like this is part of the implementation of merge(). Is there a need for it to be public?

I will refactor in a separate change set.

413 ↗

(On Diff #40201)

Will do.

include/llvm/Support/MathExtras.h

656 ↗

(On Diff #40201)

Will do.

lib/ProfileData/InstrProfWriter.cpp

120 ↗

(On Diff #40201)

OK.

tools/llvm-profdata/llvm-profdata.cpp

88 ↗

(On Diff #40201)

I assume you meant 'does not seem to be a need'?

OK. That will mean making a copy of the record internally in order to scale it since AddRecord shouldn't assume that it is allowed to mutate the passed in record.

The other alternative is to revert to the previous method of applying the weight during merge. That would be more efficient (than making a temporary scaled record) but spreads out the weighting logic across a number of methods.

[silvas]

tools/llvm-profdata/llvm-profdata.cpp

155 ↗

(On Diff #40201)

http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly
(here and doublecheck elsewhere)

158 ↗

(On Diff #40201)

typo "postive"

[slingn]

Updated for davidxl and silvas feedback.

Split changes not directly related to weighted merging into separate patches which are now merged.

[silvas]

docs/CommandGuide/llvm-profdata.rst

31 ↗

(On Diff #41681)

this is confusing. I interpret filenames[:weights]... as that there are multiple weights for a given filename. It seems like filename[:weight] ... is a better way to describe it. The repetition comes from the ... not from the plurality of the name (I would say that what was there previously was incorrect).

40 ↗

(On Diff #41681)

This isn't a very user-friendly description. I would describe it as: "instead of <filename> pass <filename>:<weight>, where <weight> is a decimal integer >= 1. A weight of 1 is assume if just <filename> by itself is passed"

[slingn]

Updated for silvas feedback.

[davidxl]

include/llvm/ProfileData/InstrProf.h

445 ↗

(On Diff #41684)

It might be better to refactor the 'fused' Multiple/Add into a helper -- it is used in two different places.

include/llvm/ProfileData/SampleProf.h

239 ↗

(On Diff #41684)

Why is SaturatingAdd not used here?

245 ↗

(On Diff #41684)

Same here.

[slingn]

include/llvm/ProfileData/InstrProf.h

445 ↗

(On Diff #41684)

That sounds like a good idea. I'll do that in a separate change.

include/llvm/ProfileData/SampleProf.h

239 ↗

(On Diff #41684)

Good question. I'll make that change in a separate patch since it is changing the existing semantics and should have its own unit tests.

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

 .. _profdata-merge:
 
 MERGE
 -----
 
 SYNOPSIS
 ^^^^^^^^
 
-:program:`llvm-profdata merge` [*options*] [*filenames...*]
+:program:`llvm-profdata merge` [*options*] [*filename[:weight]...*]
 
 DESCRIPTION
 ^^^^^^^^^^^
 
 :program:`llvm-profdata merge` takes several profile data files
 generated by PGO instrumentation and merges them together into a single
 indexed profile data file.
 
+The profile counts in each input file can be scaled (multiplied) by specifying
+``<filename>:<weight>``, where `<weight>` is a decimal integer >= 1.
+A default weight of 1 is assumed if only `<filename>` is given.
+
 OPTIONS
 ^^^^^^^
 
 .. option:: -help
 
  Print a summary of command line options.
 
 .. option:: -output=output, -o=output

llvm/trunk/include/llvm/ProfileData/InstrProf.h

struct InstrProfValueSiteRecord {
   void sortByTargetValues() {
     ValueData.sort(
         [](const InstrProfValueData &left, const InstrProfValueData &right) {
           return left.Value < right.Value;
         });
   }
 
   /// Merge data from another InstrProfValueSiteRecord
-  void mergeValueData(InstrProfValueSiteRecord &Input) {
+  /// Optionally scale merged counts by \p Weight.
+  void mergeValueData(InstrProfValueSiteRecord &Input, uint64_t Weight = 1) {
     this->sortByTargetValues();
     Input.sortByTargetValues();
     auto I = ValueData.begin();
     auto IE = ValueData.end();
     for (auto J = Input.ValueData.begin(), JE = Input.ValueData.end(); J != JE;
          ++J) {
       while (I != IE && I->Value < J->Value)
         ++I;
       if (I != IE && I->Value == J->Value) {
-        I->Count = SaturatingAdd(I->Count, J->Count);
+        // TODO: Check for counter overflow and return error if it occurs.
+        uint64_t JCount = J->Count;
+        if (Weight > 1)
+          JCount = SaturatingMultiply(JCount, Weight);
+        I->Count = SaturatingAdd(I->Count, JCount);
         ++I;
         continue;
       }
       ValueData.insert(I, *J);
     }
   }
 };
 
struct InstrProfRecord {
   /// Reserve space for NumValueSites sites.
   inline void reserveSites(uint32_t ValueKind, uint32_t NumValueSites);
   /// Add ValueData for ValueKind at value Site.
   inline void addValueData(uint32_t ValueKind, uint32_t Site,
                            InstrProfValueData *VData, uint32_t N,
                            ValueMapType *HashKeys);
 
   /// Merge the counts in \p Other into this one.
-  inline instrprof_error merge(InstrProfRecord &Other);
+  /// Optionally scale merged counts by \p Weight.
+  inline instrprof_error merge(InstrProfRecord &Other, uint64_t Weight = 1);
 
   /// Used by InstrProfWriter: update the value strings to commoned strings in
   /// the writer instance.
   inline void updateStrings(InstrProfStringTable *StrTab);
 
   /// Clear value data entries
   inline void clearValueData() {
     for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
case IPVK_IndirectCallTarget: {
         Value = (uint64_t)Result->second;
       break;
     }
     }
     return Value;
   }
 
   // Merge Value Profile data from Src record to this record for ValueKind.
-  instrprof_error mergeValueProfData(uint32_t ValueKind, InstrProfRecord &Src) {
+  // Scale merged value counts by \p Weight.
+  instrprof_error mergeValueProfData(uint32_t ValueKind, InstrProfRecord &Src,
+                                     uint64_t Weight) {
     uint32_t ThisNumValueSites = getNumValueSites(ValueKind);
     uint32_t OtherNumValueSites = Src.getNumValueSites(ValueKind);
     if (ThisNumValueSites != OtherNumValueSites)
       return instrprof_error::value_site_count_mismatch;
     std::vector<InstrProfValueSiteRecord> &ThisSiteRecords =
         getValueSitesForKind(ValueKind);
     std::vector<InstrProfValueSiteRecord> &OtherSiteRecords =
         Src.getValueSitesForKind(ValueKind);
     for (uint32_t I = 0; I < ThisNumValueSites; I++)
-      ThisSiteRecords[I].mergeValueData(OtherSiteRecords[I]);
+      ThisSiteRecords[I].mergeValueData(OtherSiteRecords[I], Weight);
     return instrprof_error::success;
   }
 };
 
 uint32_t InstrProfRecord::getNumValueKinds() const {
   uint32_t NumValueKinds = 0;
   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
     NumValueKinds += !(getValueSitesForKind(Kind).empty());
if (!StrTab)
     return;
 
   Name = StrTab->insertString(Name);
   for (auto &VSite : IndirectCallSites)
     for (auto &VData : VSite.ValueData)
       VData.Value = (uint64_t)StrTab->insertString((const char *)VData.Value);
 }
 
-instrprof_error InstrProfRecord::merge(InstrProfRecord &Other) {
+instrprof_error InstrProfRecord::merge(InstrProfRecord &Other,
+                                       uint64_t Weight) {
   // If the number of counters doesn't match we either have bad data
   // or a hash collision.
   if (Counts.size() != Other.Counts.size())
     return instrprof_error::count_mismatch;
 
   instrprof_error Result = instrprof_error::success;
 
   for (size_t I = 0, E = Other.Counts.size(); I < E; ++I) {
     bool ResultOverflowed;
-    Counts[I] = SaturatingAdd(Counts[I], Other.Counts[I], ResultOverflowed);
+    uint64_t OtherCount = Other.Counts[I];
+    if (Weight > 1) {
+      OtherCount = SaturatingMultiply(OtherCount, Weight, ResultOverflowed);
+      if (ResultOverflowed)
+        Result = instrprof_error::counter_overflow;
+    }
+    Counts[I] = SaturatingAdd(Counts[I], OtherCount, ResultOverflowed);
     if (ResultOverflowed)
       Result = instrprof_error::counter_overflow;
   }
 
   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind) {
-    instrprof_error MergeValueResult = mergeValueProfData(Kind, Other);
+    instrprof_error MergeValueResult = mergeValueProfData(Kind, Other, Weight);
     if (MergeValueResult != instrprof_error::success)
       Result = MergeValueResult;
   }
 
   return Result;
 }
 
 inline support::endianness getHostEndianness() {

llvm/trunk/include/llvm/ProfileData/InstrProfWriter.h

private:
   uint64_t MaxFunctionCount;
 public:
   InstrProfWriter() : MaxFunctionCount(0) {}
 
   /// Update string entries in profile data with references to StringTable.
   void updateStringTableReferences(InstrProfRecord &I);
   /// Add function counts for the given function. If there are already counts
   /// for this function and the hash and number of counts match, each counter is
-  /// summed.
-  std::error_code addRecord(InstrProfRecord &&I);
+  /// summed. Optionally scale counts by \p Weight.
+  std::error_code addRecord(InstrProfRecord &&I, uint64_t Weight = 1);
   /// Write the profile to \c OS
   void write(raw_fd_ostream &OS);
   /// Write the profile in text format to \c OS
   void writeText(raw_fd_ostream &OS);
   /// Write \c Record in text format to \c OS
   static void writeRecordInText(const InstrProfRecord &Record,
                                 raw_fd_ostream &OS);
   /// Write the profile, returning the raw data. For testing.

llvm/trunk/include/llvm/ProfileData/SampleProf.h

 /// will be a list of one or more functions.
 class SampleRecord {
 public:
   typedef StringMap<uint64_t> CallTargetMap;
 
   SampleRecord() : NumSamples(0), CallTargets() {}
 
   /// Increment the number of samples for this record by \p S.
+  /// Optionally scale sample count \p S by \p Weight.
   ///
   /// Sample counts accumulate using saturating arithmetic, to avoid wrapping
   /// around unsigned integers.
-  void addSamples(uint64_t S) {
+  void addSamples(uint64_t S, uint64_t Weight = 1) {
+    if (Weight > 1)
+      S = SaturatingMultiply(S, Weight);
     NumSamples = SaturatingAdd(NumSamples, S);
   }
 
   /// Add called function \p F with samples \p S.
+  /// Optionally scale sample count \p S by \p Weight.
   ///
   /// Sample counts accumulate using saturating arithmetic, to avoid wrapping
   /// around unsigned integers.
-  void addCalledTarget(StringRef F, uint64_t S) {
+  void addCalledTarget(StringRef F, uint64_t S, uint64_t Weight = 1) {
     uint64_t &TargetSamples = CallTargets[F];
+    if (Weight > 1)
+      S = SaturatingMultiply(S, Weight);
     TargetSamples = SaturatingAdd(TargetSamples, S);
   }
 
   /// Return true if this sample record contains function calls.
   bool hasCalls() const { return CallTargets.size() > 0; }
 
   uint64_t getSamples() const { return NumSamples; }
   const CallTargetMap &getCallTargets() const { return CallTargets; }
 
   /// Merge the samples in \p Other into this record.
-  void merge(const SampleRecord &Other) {
-    addSamples(Other.getSamples());
+  /// Optionally scale sample counts by \p Weight.
+  void merge(const SampleRecord &Other, uint64_t Weight = 1) {
+    addSamples(Other.getSamples(), Weight);
     for (const auto &I : Other.getCallTargets())
-      addCalledTarget(I.first(), I.second);
+      addCalledTarget(I.first(), I.second, Weight);
   }
 
   void print(raw_ostream &OS, unsigned Indent) const;
   void dump() const;
 
 private:
   uint64_t NumSamples;
   CallTargetMap CallTargets;

 /// This data structure contains all the collected samples for the body
 /// of a function. Each sample corresponds to a LineLocation instance
 /// within the body of the function.
 class FunctionSamples {
 public:
   FunctionSamples() : TotalSamples(0), TotalHeadSamples(0) {}
   void print(raw_ostream &OS = dbgs(), unsigned Indent = 0) const;
   void dump() const;
-  void addTotalSamples(uint64_t Num) { TotalSamples += Num; }
-  void addHeadSamples(uint64_t Num) { TotalHeadSamples += Num; }
-  void addBodySamples(uint32_t LineOffset, uint32_t Discriminator,
-                      uint64_t Num) {
-    BodySamples[LineLocation(LineOffset, Discriminator)].addSamples(Num);
+  void addTotalSamples(uint64_t Num, uint64_t Weight = 1) {
+    if (Weight > 1)
+      Num = SaturatingMultiply(Num, Weight);
+    TotalSamples += Num;
+  }
+  void addHeadSamples(uint64_t Num, uint64_t Weight = 1) {
+    if (Weight > 1)
+      Num = SaturatingMultiply(Num, Weight);
+    TotalHeadSamples += Num;
+  }
+  void addBodySamples(uint32_t LineOffset, uint32_t Discriminator, uint64_t Num,
+                      uint64_t Weight = 1) {
+    BodySamples[LineLocation(LineOffset, Discriminator)].addSamples(Num,
+                                                                    Weight);
   }
   void addCalledTargetSamples(uint32_t LineOffset, uint32_t Discriminator,
-                              std::string FName, uint64_t Num) {
-    BodySamples[LineLocation(LineOffset, Discriminator)].addCalledTarget(FName,
-                                                                         Num);
+                              std::string FName, uint64_t Num,
+                              uint64_t Weight = 1) {
+    BodySamples[LineLocation(LineOffset, Discriminator)].addCalledTarget(
+        FName, Num, Weight);
   }
 
   /// Return the number of samples collected at the given location.
   /// Each location is specified by \p LineOffset and \p Discriminator.
   /// If the location is not found in profile, return error.
   ErrorOr<uint64_t> findSamplesAt(uint32_t LineOffset,
                                   uint32_t Discriminator) const {
     const auto &ret = BodySamples.find(LineLocation(LineOffset, Discriminator));
public:
   const BodySampleMap &getBodySamples() const { return BodySamples; }
 
   /// Return all the callsite samples collected in the body of the function.
   const CallsiteSampleMap &getCallsiteSamples() const {
     return CallsiteSamples;
   }
 
   /// Merge the samples in \p Other into this one.
-  void merge(const FunctionSamples &Other) {
-    addTotalSamples(Other.getTotalSamples());
-    addHeadSamples(Other.getHeadSamples());
+  /// Optionally scale samples by \p Weight.
+  void merge(const FunctionSamples &Other, uint64_t Weight = 1) {
+    addTotalSamples(Other.getTotalSamples(), Weight);
+    addHeadSamples(Other.getHeadSamples(), Weight);
     for (const auto &I : Other.getBodySamples()) {
       const LineLocation &Loc = I.first;
       const SampleRecord &Rec = I.second;
-      BodySamples[Loc].merge(Rec);
+      BodySamples[Loc].merge(Rec, Weight);
     }
     for (const auto &I : Other.getCallsiteSamples()) {
       const CallsiteLocation &Loc = I.first;
       const FunctionSamples &Rec = I.second;
-      functionSamplesAt(Loc).merge(Rec);
+      functionSamplesAt(Loc).merge(Rec, Weight);
     }
   }
 
 private:
   /// Total number of samples collected inside this function.
   ///
   /// Samples are cumulative, they include all the samples collected
   /// inside this function and all its inlined callees.

llvm/trunk/lib/ProfileData/InstrProfWriter.cpp

void InstrProfWriter::setValueProfDataEndianness(
     support::endianness Endianness) {
   ValueProfDataEndianness = Endianness;
 }
 
 void InstrProfWriter::updateStringTableReferences(InstrProfRecord &I) {
   I.updateStrings(&StringTable);
 }
 
-std::error_code InstrProfWriter::addRecord(InstrProfRecord &&I) {
+std::error_code InstrProfWriter::addRecord(InstrProfRecord &&I,
+                                           uint64_t Weight) {
   updateStringTableReferences(I);
   auto &ProfileDataMap = FunctionData[I.Name];
 
   bool NewFunc;
   ProfilingData::iterator Where;
   std::tie(Where, NewFunc) =
       ProfileDataMap.insert(std::make_pair(I.Hash, InstrProfRecord()));
   InstrProfRecord &Dest = Where->second;
 
   instrprof_error Result;
   if (NewFunc) {
     // We've never seen a function with this name and hash, add it.
     Dest = std::move(I);
     Result = instrprof_error::success;
+    if (Weight > 1) {
+      for (auto &Count : Dest.Counts) {
+        bool Overflowed;
+        Count = SaturatingMultiply(Count, Weight, Overflowed);
+        if (Overflowed && Result == instrprof_error::success) {
+          Result = instrprof_error::counter_overflow;
+        }
+      }
+    }
   } else {
     // We're updating a function we've seen before.
-    Result = Dest.merge(I);
+    Result = Dest.merge(I, Weight);
   }
 
   // We keep track of the max function count as we go for simplicity.
   // Update this statistic no matter the result of the merge.
   if (Dest.Counts[0] > MaxFunctionCount)
     MaxFunctionCount = Dest.Counts[0];
 
   return Result;

llvm/trunk/test/tools/llvm-profdata/Inputs/weight-sample-bar.proftext

+bar:1772037:35370
+ 17: 35370
+ 18: 35370
+ 19: 7005
+ 20: 29407
+ 21: 12170
+ 23: 18150 bar:19829
+ 25: 36666

llvm/trunk/test/tools/llvm-profdata/Inputs/weight-sample-foo.proftext

+foo:1763288:35327
+ 7: 35327
+ 8: 35327
+ 9: 6930
+ 10: 29341
+ 11: 11906
+ 13: 18185 foo:19531
+ 15: 36458

llvm/trunk/test/tools/llvm-profdata/weight-instr.test

+Tests for weighted merge of instrumented profiles.
+
+1- Merge the foo and bar profiles with unity weight and verify the combined output
+RUN: llvm-profdata merge --instr %p/Inputs/weight-instr-bar.profdata:1 %p/Inputs/weight-instr-foo.profdata:1 -o %t
+RUN: llvm-profdata show --instr -all-functions %t | FileCheck %s --check-prefix=WEIGHT1
+WEIGHT1: Counters:
+WEIGHT1:   usage:
+WEIGHT1:     Hash: 0x0000000000000000
+WEIGHT1:     Counters: 1
+WEIGHT1:     Function count: 0
+WEIGHT1:   foo:
+WEIGHT1:     Hash: 0x000000000000028a
+WEIGHT1:     Counters: 3
+WEIGHT1:     Function count: 866988873
+WEIGHT1:   bar:
+WEIGHT1:     Hash: 0x000000000000028a
+WEIGHT1:     Counters: 3
+WEIGHT1:     Function count: 866988873
+WEIGHT1:   main:
+WEIGHT1:     Hash: 0x7d31c47ea98f8248
+WEIGHT1:     Counters: 60
+WEIGHT1:     Function count: 2
+WEIGHT1: Functions shown: 4
+WEIGHT1: Total functions: 4
+WEIGHT1: Maximum function count: 866988873
+WEIGHT1: Maximum internal block count: 267914296
+
+2- Merge the foo and bar profiles with weight 3x and 5x respectively and verify the combined output
+RUN: llvm-profdata merge --instr %p/Inputs/weight-instr-bar.profdata:3 %p/Inputs/weight-instr-foo.profdata:5 -o %t
+RUN: llvm-profdata show --instr -all-functions %t | FileCheck %s --check-prefix=WEIGHT2
+WEIGHT2: Counters:
+WEIGHT2:   usage:
+WEIGHT2:     Hash: 0x0000000000000000
+WEIGHT2:     Counters: 1
+WEIGHT2:     Function count: 0
+WEIGHT2:   foo:
+WEIGHT2:     Hash: 0x000000000000028a
+WEIGHT2:     Counters: 3
+WEIGHT2:     Function count: 4334944365
+WEIGHT2:   bar:
+WEIGHT2:     Hash: 0x000000000000028a
+WEIGHT2:     Counters: 3
+WEIGHT2:     Function count: 2600966619
+WEIGHT2:   main:
+WEIGHT2:     Hash: 0x7d31c47ea98f8248
+WEIGHT2:     Counters: 60
+WEIGHT2:     Function count: 8
+WEIGHT2: Functions shown: 4
+WEIGHT2: Total functions: 4
+WEIGHT2: Maximum function count: 4334944365
+WEIGHT2: Maximum internal block count: 1339571480
+
+3- Bad merge: foo and bar profiles with invalid weights
+RUN: not llvm-profdata merge --instr %p/Inputs/weight-instr-bar.profdata:3 %p/Inputs/weight-instr-foo.profdata:-5 -o %t.out 2>&1 | FileCheck %s --check-prefix=ERROR3
+ERROR3: error: Input weight must be a positive integer.

llvm/trunk/test/tools/llvm-profdata/weight-sample.test

+Tests for weighted merge of sample profiles.
+
+1- Merge the foo and bar profiles with unity weight and verify the combined output
+RUN: llvm-profdata merge --sample --text %p/Inputs/weight-sample-bar.proftext:1 %p/Inputs/weight-sample-foo.proftext:1 -o - | FileCheck %s --check-prefix=WEIGHT1
+WEIGHT1: foo:1763288:35327
+WEIGHT1:  7: 35327
+WEIGHT1:  8: 35327
+WEIGHT1:  9: 6930
+WEIGHT1:  10: 29341
+WEIGHT1:  11: 11906
+WEIGHT1:  13: 18185 foo:19531
+WEIGHT1:  15: 36458
+WEIGHT1: bar:1772037:35370
+WEIGHT1:  17: 35370
+WEIGHT1:  18: 35370
+WEIGHT1:  19: 7005
+WEIGHT1:  20: 29407
+WEIGHT1:  21: 12170
+WEIGHT1:  23: 18150 bar:19829
+WEIGHT1:  25: 36666
+
+2- Merge the foo and bar profiles with weight 3x and 5x respectively and verify the combined output
+RUN: llvm-profdata merge --sample --text %p/Inputs/weight-sample-bar.proftext:3 %p/Inputs/weight-sample-foo.proftext:5 -o - | FileCheck %s --check-prefix=WEIGHT2
+WEIGHT2: foo:8816440:176635
+WEIGHT2:  7: 176635
+WEIGHT2:  8: 176635
+WEIGHT2:  9: 34650
+WEIGHT2:  10: 146705
+WEIGHT2:  11: 59530
+WEIGHT2:  13: 90925 foo:97655
+WEIGHT2:  15: 182290
+WEIGHT2: bar:5316111:106110
+WEIGHT2:  17: 106110
+WEIGHT2:  18: 106110
+WEIGHT2:  19: 21015
+WEIGHT2:  20: 88221
+WEIGHT2:  21: 36510
+WEIGHT2:  23: 54450 bar:59487
+WEIGHT2:  25: 109998
+
+3- Bad merge: foo and bar profiles with invalid weights
+RUN: not llvm-profdata merge --sample --text %p/Inputs/weight-sample-bar.proftext:3 %p/Inputs/weight-sample-foo.proftext:-5 -o %t.out 2>&1 | FileCheck %s --check-prefix=ERROR3
+ERROR3: error: Input weight must be a positive integer.

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

 //===- llvm-profdata.cpp - LLVM profile data tool -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // llvm-profdata merges .profdata files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ProfileData/InstrProfWriter.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/ProfileData/SampleProfWriter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
+#include <tuple>
 
 using namespace llvm;
 
 enum ProfileFormat { PF_None = 0, PF_Text, PF_Binary, PF_GCC };
 
 static void exitWithError(const Twine &Message,
                           StringRef Whence = "",
                           StringRef Hint = "") {
if (Error.category() == instrprof_category()) {
       }
     }
 
     if (!Hint.empty())
       errs() << Hint << "\n";
   }
 }
 
-static void mergeInstrProfile(const cl::list<std::string> &Inputs,
+struct WeightedFile {
+  StringRef Filename;
+  uint64_t Weight;
+
+  WeightedFile() {}
+
+  WeightedFile(StringRef F, uint64_t W) : Filename{F}, Weight{W} {}
+};
+typedef SmallVector<WeightedFile, 5> WeightedFileVector;
+
+static void mergeInstrProfile(const WeightedFileVector &Inputs,
                               StringRef OutputFilename,
                               ProfileFormat OutputFormat) {
   if (OutputFilename.compare("-") == 0)
     exitWithError("Cannot write indexed profdata format to stdout.");
 
   if (OutputFormat != PF_Binary && OutputFormat != PF_Text)
     exitWithError("Unknown format is specified.");
 
   std::error_code EC;
   raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::F_None);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   InstrProfWriter Writer;
   SmallSet<std::error_code, 4> WriterErrorCodes;
-  for (const auto &Filename : Inputs) {
-    auto ReaderOrErr = InstrProfReader::create(Filename);
+  for (const auto &Input : Inputs) {
+    auto ReaderOrErr = InstrProfReader::create(Input.Filename);
     if (std::error_code ec = ReaderOrErr.getError())
-      exitWithErrorCode(ec, Filename);
+      exitWithErrorCode(ec, Input.Filename);
 
     auto Reader = std::move(ReaderOrErr.get());
     for (auto &I : *Reader) {
-      if (std::error_code EC = Writer.addRecord(std::move(I))) {
+      if (std::error_code EC = Writer.addRecord(std::move(I), Input.Weight)) {
         // Only show hint the first time an error occurs.
         bool firstTime = WriterErrorCodes.insert(EC).second;
-        handleMergeWriterError(EC, Filename, I.Name, firstTime);
+        handleMergeWriterError(EC, Input.Filename, I.Name, firstTime);
       }
     }
     if (Reader->hasError())
-      exitWithErrorCode(Reader->getError(), Filename);
+      exitWithErrorCode(Reader->getError(), Input.Filename);
   }
   if (OutputFormat == PF_Text)
     Writer.writeText(Output);
   else
     Writer.write(Output);
 }
 
 static sampleprof::SampleProfileFormat FormatMap[] = {
     sampleprof::SPF_None, sampleprof::SPF_Text, sampleprof::SPF_Binary,
     sampleprof::SPF_GCC};
 
-static void mergeSampleProfile(const cl::list<std::string> &Inputs,
+static void mergeSampleProfile(const WeightedFileVector &Inputs,
                                StringRef OutputFilename,
                                ProfileFormat OutputFormat) {
   using namespace sampleprof;
   auto WriterOrErr =
       SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]);
   if (std::error_code EC = WriterOrErr.getError())
     exitWithErrorCode(EC, OutputFilename);
 
   auto Writer = std::move(WriterOrErr.get());
   StringMap<FunctionSamples> ProfileMap;
   SmallVector<std::unique_ptr<sampleprof::SampleProfileReader>, 5> Readers;
-  for (const auto &Filename : Inputs) {
+  for (const auto &Input : Inputs) {
     auto ReaderOrErr =
-        SampleProfileReader::create(Filename, getGlobalContext());
+        SampleProfileReader::create(Input.Filename, getGlobalContext());
     if (std::error_code EC = ReaderOrErr.getError())
-      exitWithErrorCode(EC, Filename);
+      exitWithErrorCode(EC, Input.Filename);
 
     // We need to keep the readers around until after all the files are
     // read so that we do not lose the function names stored in each
     // reader's memory. The function names are needed to write out the
     // merged profile map.
     Readers.push_back(std::move(ReaderOrErr.get()));
     const auto Reader = Readers.back().get();
     if (std::error_code EC = Reader->read())
-      exitWithErrorCode(EC, Filename);
+      exitWithErrorCode(EC, Input.Filename);
 
     StringMap<FunctionSamples> &Profiles = Reader->getProfiles();
     for (StringMap<FunctionSamples>::iterator I = Profiles.begin(),
                                               E = Profiles.end();
          I != E; ++I) {
       StringRef FName = I->first();
       FunctionSamples &Samples = I->second;
-      ProfileMap[FName].merge(Samples);
+      ProfileMap[FName].merge(Samples, Input.Weight);
     }
   }
   Writer->write(ProfileMap);
 }
 
+static void parseInputFiles(const cl::list<std::string> &Inputs,
+                            WeightedFileVector &WeightedInputs) {
+  WeightedInputs.reserve(Inputs.size());
+
+  for (StringRef Input : Inputs) {
+    StringRef FileName;
+    StringRef WeightStr;
+    std::tie(FileName, WeightStr) = Input.rsplit(':');
+    if (WeightStr.empty() || sys::fs::exists(Input)) {
+      // No weight specified or valid path containing delimiter.
+      WeightedInputs.push_back(WeightedFile(Input, 1));
+    } else {
+      // Input weight specified.
+      uint64_t Weight;
+      if (WeightStr.getAsInteger(10, Weight) || Weight < 1) {
+        // Invalid input weight.
+        exitWithError("Input weight must be a positive integer.");
+      }
+      WeightedInputs.push_back(WeightedFile(FileName, Weight));
+    }
+  }
+}
+
 static int merge_main(int argc, const char *argv[]) {
   cl::list<std::string> Inputs(cl::Positional, cl::Required, cl::OneOrMore,
-                               cl::desc("<filenames...>"));
+                               cl::desc("<filename[:weight]...>"));
 
   cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
                                       cl::init("-"), cl::Required,
                                       cl::desc("Output file"));
   cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
                             cl::aliasopt(OutputFilename));
   cl::opt<ProfileKinds> ProfileKind(
       cl::desc("Profile kind:"), cl::init(instr),
       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
                  clEnumVal(sample, "Sample profile"), clEnumValEnd));
 
   cl::opt<ProfileFormat> OutputFormat(
       cl::desc("Format of output profile"), cl::init(PF_Binary),
       cl::values(clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
                  clEnumValN(PF_Text, "text", "Text encoding"),
                  clEnumValN(PF_GCC, "gcc",
                             "GCC encoding (only meaningful for -sample)"),
                  clEnumValEnd));
 
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
 
+  WeightedFileVector WeightedInputs;
+  parseInputFiles(Inputs, WeightedInputs);
+
   if (ProfileKind == instr)
-    mergeInstrProfile(Inputs, OutputFilename, OutputFormat);
+    mergeInstrProfile(WeightedInputs, OutputFilename, OutputFormat);
   else
-    mergeSampleProfile(Inputs, OutputFilename, OutputFormat);
+    mergeSampleProfile(WeightedInputs, OutputFilename, OutputFormat);
 
   return 0;
 }
 
 static int showInstrProfile(std::string Filename, bool ShowCounts,
                             bool ShowIndirectCallTargets, bool ShowAllFunctions,
                             std::string ShowFunction, bool TextFormat,
                             raw_fd_ostream &OS) {

llvm/trunk/unittests/ProfileData/InstrProfTest.cpp

TEST_F(InstrProfTest, get_max_function_count) {
   Writer.addRecord(std::move(Record2));
   Writer.addRecord(std::move(Record3));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   ASSERT_EQ(1ULL << 63, Reader->getMaximumFunctionCount());
 }
 
+TEST_F(InstrProfTest, get_weighted_function_counts) {
+  InstrProfRecord Record1("foo", 0x1234, {1, 2});
+  InstrProfRecord Record2("foo", 0x1235, {3, 4});
+  Writer.addRecord(std::move(Record1), 3);
+  Writer.addRecord(std::move(Record2), 5);
+  auto Profile = Writer.writeBuffer();
+  readProfile(std::move(Profile));
+
+  std::vector<uint64_t> Counts;
+  ASSERT_TRUE(NoError(Reader->getFunctionCounts("foo", 0x1234, Counts)));
+  ASSERT_EQ(2U, Counts.size());
+  ASSERT_EQ(3U, Counts[0]);
+  ASSERT_EQ(6U, Counts[1]);
+
+  ASSERT_TRUE(NoError(Reader->getFunctionCounts("foo", 0x1235, Counts)));
+  ASSERT_EQ(2U, Counts.size());
+  ASSERT_EQ(15U, Counts[0]);
+  ASSERT_EQ(20U, Counts[1]);
+}
+
 } // end anonymous namespace