[llvm-profdata] Add support for weighted merge of profile data (2nd try)

[slingn]

Summary

This change adds support for specifying a weight when merging profile data with the llvm-profdata tool.
Weights are specified by using the --weighted-input=<weight>,<filename> option. Input files not specified
with this option (normal positional list after options) are given a default weight of 1.

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.

[slingn]

Diff 1 is the baseline change from D14547. The fix for the Windows test failure isn't quite 'trivial' so I'm going to make that Diff 2.

[slingn]

Fix for Windows test failure.

[davidxl]

What kind of windows test failure was there?

David

[slingn]

Failed builds:

http://lab.llvm.org:8011/builders/clang-x64-ninja-win7/builds/7858
http://lab.llvm.org:8011/builders/clang-x86-win2008-selfhost/builds/4929

Before we try to parse the weight from each input file we check if the file exists with sys::fs::exists(). This was done to allow file names to still include the ':' delimiter character - especially important on Windows since many file paths contain ':'.

Unfortunately, this check isn't foolproof as it appears to not handle the case of mixed path delimiters as we have when running the tests:

llvm-profdata.EXE merge D:\buildslave\clang-x64-ninja-win7\llvm\test\tools\llvm-profdata/Inputs/invalid-count-later.proftext D:\buildslave\clang-x64-ninja-win7\llvm\test\tools\llvm-profdata/Inputs/invalid-count-later.profdata -o D:\buildslave\clang-x64-ninja-win7\stage2\test\tools\llvm-profdata\Output\text-format-errors.test.tmp.out

[slingn]

BTW - I was able to reproduce the failure and verify the fix on Windows 7 / Visual Studio 2013.

[davidxl]

tools/llvm-profdata/llvm-profdata.cpp

198 ↗

(On Diff #42107)

Can you add a comment indicating this works around a bug in sys::fs::exists()?

[slingn]

Updated for davidxl's comments.

[slingn]

tools/llvm-profdata/llvm-profdata.cpp

198 ↗

(On Diff #42120)

It isn't exclusively a work-around for the issue with sys::fs::exists() - but I've tried to make the explanation clearer in the comments.

With this check the user will get a meaningful error message (file not found) on UNIX in the (obscure) situation of an invalid path containing ':'.

[slingn]

OK, so it's not a bug in sys::fs::exists(). It's a bug in the test script text-format-errors.text:

1- Detect invalid count
RUN: not llvm-profdata show %p/Inputs/invalid-count-later.proftext 2>&1 | FileCheck %s --check-prefix=INVALID-COUNT-LATER
RUN: not llvm-profdata merge %p/Inputs/invalid-count-later.proftext %p/Inputs/invalid-count-later.profdata -o %t.out 2>&1 | FileCheck %s --check-prefix=INVALID-COUNT-LATER
INVALID-COUNT-LATER: error: {{.*}}invalid-count-later.proftext: Malformed instrumentation profile data

I stepped through with a debugger:

"C:/Users/Nathan/Sandbox/llvm/build/Debug/bin\llvm-profdata.EXE" "merge" "C:\Users\Nathan\Sandbox\llvm\test\tools\llvm-profdata/Inputs/invalid-count-later.proftext" "C:\Users\Nathan\Sandbox\llvm\test\tools\llvm-profdata/Inputs/invalid-count-later.profdata" "-o" "C:\Users\Nathan\Sandbox\llvm\build\test\tools\llvm-profdata\Output\text-format-errors.test.tmp.out"

Input 1: C:\Users\Nathan\Sandbox\llvm\test\tools\llvm-profdata/Inputs/invalid-count-later.proftext
Input 2: C:\Users\Nathan\Sandbox\llvm\test\tools\llvm-profdata/Inputs/invalid-count-later.profdata
                                                                                          ^^^^^^^^

And what do you know, the first mixed path exists and the check works just fine. The problem is that the second path really doesn't exist - so sys::fs::exists() rightly points this out:

bad-hash.proftext   compat.profdata.v2   foo3bar3-1.proftext           sample-profile.proftext      weight-sample-foo.proftext
bar3-1.proftext     empty.proftext       gcc-sample-profile.gcov       text-format-errors.text.bin
basic.proftext      extra-word.proftext  inline-samples.afdo           weight-instr-bar.profdata
c-general.profraw   foo3-1.proftext      invalid-count-later.proftext  weight-instr-foo.profdata
compat.profdata.v1  foo3-2.proftext      no-counts.proftext            weight-sample-bar.proftext

[slingn]

I still think a check is a good idea for the edge case mentioned above (input contains ':' but is not specifying a weight and does not exist) so that the error message is correct. But thankfully I think since sys::fs::exists() works we can just check if the split path exists - if it doesn't fall back to default behavior. Hopefully that's a more appealing way to do this.

[davidxl]

I think the right fix is:

StringRef WeightStr;
​std::tie(FileName, WeightStr) = Input.rsplit(':');
​ if (!sys::fs::exists(FileName) && !sys::fs::exists(Input)) {

  // report missing file error;
}
else if (sys::fs::exists(Input)) {
  // add input 
 }
else {
   assert (!WeightStr.empty());
   // check WeightStr format 
   ...
}

​

[slingn]

Updated for davidxl and bogner's comments.

Improves handling of invalid paths vs. invalid weights. Adds tests.

[silvas]

Given the subtleties we've encountered, I propose we switch over to using the syntax --weighted-file=<weight>,<filename> (or similar). This eliminates the special cases and is easier to document without subtly lying about the true behavior.

[davidxl]

The subtlety is pretty well understood and the solution to it is clean

• I don't see a strong reason to introduce a new option.

David

[slingn]

From the end user's perspective the <filename>:<weight> syntax seems the most intuitive and concise. And no matter what delimiter we choose (even with a separate option) there will still be edge cases for us to differentiate between file names containing ',' and the user trying but failing to specify a weight.

[silvas]

In D15306#307232, @slingn wrote:

From the end user's perspective the <filename>:<weight> syntax seems the most intuitive and concise. And no matter what delimiter we choose (even with a separate option) there will still be edge cases for us to differentiate between file names containing ',' and the user trying but failing to specify a weight.

I disagree. With <filename>:<weight> the way to robustly invoke the tool programmatically is non-obvious; for example, the presence of random other files will change our interpretation and cause an error. A tool like this should only look at the files it is told to look at, and no more; with <filename>:<weight> we cannot even begin to approach that standard since it is ambiguous which files we should even look at.

With an explicit option, it is something like '--weighted-file=' + str(weight) + ',' + filename which always works as expected (when the weight and filename are valid, which is the case I'm talking about).

Also, note that nothing about this is "intuitive" (unless you know of analogous tools that use that particular syntax, but I'm not aware of any). Intuition comes from past experience. People will learn about this feature of llvm-profdata from our documentation; it isn't trying to be compatible with anything and user's don't have any preconceived notions about how it should work. Actually, I would go so far as to say that your statement is backwards: using an option *is* intuitive because users already are already aware of the caveats of having a file whose name might be ambiguous (e.g. starts with -) and are aware of the notion of passing options to a command-line program.

Or to put it another way: we should not invent a new command line syntax. Options are the standard way to pass more than a filename.

Furthermore, using an option, we can always go back and add <filename>:<weight> if there is resounding user demand for a "more concise" syntax.

[slingn]

Adding a few others for review since this has expanded beyond 'fix the Windows test issue' for the reverted D14547.

[davidxl]

I misunderstood your proposal. Your proposal is a modified version of
the originally proposed option that requires weight to be specified
for every file (and with implicit ordering assumption). To specify
more than one file with weight, does user have to use multiple
--weight-file option?

David

[silvas]

In D15306#307692, @davidxl wrote:

I misunderstood your proposal. Your proposal is a modified version of
the originally proposed option that requires weight to be specified
for every file (and with implicit ordering assumption). To specify
more than one file with weight, does user have to use multiple
--weight-file option?

Yes. What I'm suggesting is precisely like the current patch, except that --weighted-file=<weight>,<filename> is used instead of <filename>:<weight>. (I do not care about --weighted-file syntax per se; it could be -weighted-file, -file-with-weight, etc. whatever is most convenient to implement. The fundamental thing is to reuse the user intuition about passing options in order to avoid exposing users to another special case (argument syntax is already a special case, but one that users are aware of).

[davidxl]

When a file is specified via --weighted-file, does it need to be
specified again later in the command line or it is optional?

David

[slingn]

There's one --weighted-file=<weight>,<filename> per file to merge, right?

Regarding intuition - I know I have trouble remembering the exact name of options I don't use very often. I might have a chance with a single ':'. :)

[silvas]

In D15306#307704, @slingn wrote:

There's one --weighted-file=<weight>,<filename> per file to merge, right?

Regarding intuition - I know I have trouble remember the exact name of options I don't use very often. I might have a chance with a single ':'. :)

That is not intuition; that is memorableness. The reality is that it is unlikely that a user will type in the merge step by hand except maybe to try it out once or twice at first (in which case it's all new to them anyway).

It is more important that once a user's automation has been taught to invoke the merge step, that it robustly continues to work as intended. Also, it is important for us to be able to easily communicate to them how to robustly invoke the tool.

[slingn]

OK - that makes sense to me if automated merging is expected to be the most common workflow.

[silvas]

In D15306#307704, @slingn wrote:

There's one --weighted-file=<weight>,<filename> per file to merge, right?

Sorry, missed this in my last message. Yes. Any <filename> can be replaced with --weighted-file=<weight>,<filename>. Just <filename> is equivalent to --weighted-file=1,<filename>.

A couple examples are the easiest way to explain it (especially to users) I think:

(something like this would be useful to include in the docs I think)

# Basic usage
llvm-profdata merge foo.profdata bar.profdata baz.profdata

# `foo.profdata` is especially important, multiply its counts by 10.
llvm-profdata merge --file-with-weight=10,foo.profdata bar.profdata baz.profdata
# Exactly equivalent to the previous invocation (explicit form; useful for programmatic invocation)
llvm-profdata merge --file-with-weight=10,foo.profdata --file-with-weight=1,bar.profdata --file-with-weight=1,baz.profdata

[davidxl]

sounds good to me.

David

[slingn]

Updated for silvas comments.

[silvas]

Some nits but otherwise this LGTM.

docs/CommandGuide/llvm-profdata.rst

39 ↗

(On Diff #42580)

Can you add a description of the weight stuff here and show the 3 example invocations I mentioned in http://reviews.llvm.org/D15306#307727 ?

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

6 ↗

(On Diff #42580)

The documentation says -weighted-input do we accept double dash or single dash or both? Let's make sure our tests are using the same command line invocations as our documentation indicates.

9 ↗

(On Diff #42580)

Just for safety's sake, can you use CHECK-NEXT on the subsequent lines?

20 ↗

(On Diff #42580)

Is there a more useful name than WEIGHT1? Maybe WEIGHT_UNIT_SCALING or something?

33 ↗

(On Diff #42580)

Can you use a more meaningful name than WEIGHT2 Maybe WEIGHT_3x_5x?

57 ↗

(On Diff #42580)

Can you come up with some semantically meaningful naming for the CHECK lines? Here and elsewhere.

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

56 ↗

(On Diff #42580)

These types of tests (that depend on system error messages or file paths) are notoriously brittle. I suggest searching around and looking at the patterns that other tests are using to know which regexes to use.

For example:

tools/llvm-size/basic.test:ENOENT: {{.*}}llvm-size{{(\.EXE|\.exe)?}}: {{.*}}.blah: {{[Nn]}}o such file or directory

[slingn]

Updated for silvas feedback.

[dnovillo]

I like the new way of specifying weighted input better. Thanks! This LGTM with a couple of changes below.

include/llvm/ProfileData/SampleProf.h

144 ↗

(On Diff #42751)

We should be indicating overflows somehow here. Could you for now assert that an overflow hasn't happened? Adding a FIXME for doing a more principled handling is fine for now.

189 ↗

(On Diff #42751)

Since we're using satmul, might as well change the addition to a saturating addition.

[slingn]

Updated for dnovillo feedback.

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

 .. _profdata-merge:
 
 MERGE
 -----
 
 SYNOPSIS
 ^^^^^^^^
 
-:program:`llvm-profdata merge` [*options*] [*filenames...*]
+:program:`llvm-profdata merge` [*options*] [*filename...*]
 
 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.
 
+By default profile data is merged without modification. This means that the
+relative importance of each input file is proportional to the number of samples
+or counts it contains. In general, the input from a longer training run will be
+interpreted as relatively more important than a shorter run. Depending on the
+nature of the training runs it may be useful to adjust the weight given to each
+input file by using the ``-weighted-input`` option.
+
+
 OPTIONS
 ^^^^^^^
 
 .. option:: -help
 
  Print a summary of command line options.
 
 .. option:: -output=output, -o=output
 
  Specify the output file name.  *Output* cannot be ``-`` as the resulting
  indexed profile data can't be written to standard output.
 
+.. option:: -weighted-input=weight,filename
+
+ Specify an input file name along with a weight. The profile counts of the input
+ file will be scaled (multiplied) by the supplied ``weight``, where where ``weight``
+ is a decimal integer >= 1. Input files specified without using this option are
+ assigned a default weight of 1. Examples are shown below.
+
 .. option:: -instr (default)
 
  Specify that the input profile is an instrumentation-based profile.
 
 .. option:: -sample
 
  Specify that the input profile is a sample-based profile.
  

  sample-based and instrumentation-based profile. When this option is used
  the profile will be dumped in the text format that is parsable by the profile
  reader.
 
  .. option:: -gcc
 
  Emit the profile using GCC's gcov format (Not yet supported).
 
+EXAMPLES
+^^^^^^^^
+Basic Usage
++++++++++++
+Merge three profiles:
+
+::
+
+    llvm-profdata merge foo.profdata bar.profdata baz.profdata -output merged.profdata
+
+Weighted Input
+++++++++++++++
+The input file `foo.profdata` is especially important, multiply its counts by 10:
+
+::
+
+    llvm-profdata merge -weighted-input=10,foo.profdata bar.profdata baz.profdata -output merged.profdata
+
+Exactly equivalent to the previous invocation (explicit form; useful for programmatic invocation):
+
+::
+
+    llvm-profdata merge -weighted-input=10,foo.profdata -weighted-input=1,bar.profdata -weighted-input=1,baz.profdata -output merged.profdata
+
 .. program:: llvm-profdata show
 
 .. _profdata-show:
 
 SHOW
 ----
 
 SYNOPSIS

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);
+        // FIXME: Improve handling of counter overflow.
+        uint64_t JCount = J->Count;
+        bool Overflowed;
+        if (Weight > 1) {
+          JCount = SaturatingMultiply(JCount, Weight, &Overflowed);
+          assert(!Overflowed && "Value data counter overflowed!");
+        }
+        I->Count = SaturatingAdd(I->Count, JCount, &Overflowed);
+        assert(!Overflowed && "Value data counter overflowed!");
         ++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);
-    if (ResultOverflowed)
+    bool Overflowed;
+    uint64_t OtherCount = Other.Counts[I];
+    if (Weight > 1) {
+      OtherCount = SaturatingMultiply(OtherCount, Weight, &Overflowed);
+      if (Overflowed)
+        Result = instrprof_error::counter_overflow;
+    }
+    Counts[I] = SaturatingAdd(Counts[I], OtherCount, &Overflowed);
+    if (Overflowed)
       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) { NumSamples = SaturatingAdd(NumSamples, S); }
+  void addSamples(uint64_t S, uint64_t Weight = 1) {
+    // FIXME: Improve handling of counter overflow.
+    bool Overflowed;
+    if (Weight > 1) {
+      S = SaturatingMultiply(S, Weight, &Overflowed);
+      assert(!Overflowed && "Sample counter overflowed!");
+    }
+    NumSamples = SaturatingAdd(NumSamples, S, &Overflowed);
+    assert(!Overflowed && "Sample counter overflowed!");
+  }
 
   /// 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) {
+    // FIXME: Improve handling of counter overflow.
     uint64_t &TargetSamples = CallTargets[F];
-    TargetSamples = SaturatingAdd(TargetSamples, S);
+    bool Overflowed;
+    if (Weight > 1) {
+      S = SaturatingMultiply(S, Weight, &Overflowed);
+      assert(!Overflowed && "Called target counter overflowed!");
+    }
+    TargetSamples = SaturatingAdd(TargetSamples, S, &Overflowed);
+    assert(!Overflowed && "Called target counter overflowed!");
   }
 
   /// 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) {
+    // FIXME: Improve handling of counter overflow.
+    bool Overflowed;
+    if (Weight > 1) {
+      Num = SaturatingMultiply(Num, Weight, &Overflowed);
+      assert(!Overflowed && "Total samples counter overflowed!");
+    }
+    TotalSamples = SaturatingAdd(TotalSamples, Num, &Overflowed);
+    assert(!Overflowed && "Total samples counter overflowed!");
+  }
+  void addHeadSamples(uint64_t Num, uint64_t Weight = 1) {
+    // FIXME: Improve handling of counter overflow.
+    bool Overflowed;
+    if (Weight > 1) {
+      Num = SaturatingMultiply(Num, Weight, &Overflowed);
+      assert(!Overflowed && "Total head samples counter overflowed!");
+    }
+    TotalHeadSamples = SaturatingAdd(TotalHeadSamples, Num, &Overflowed);
+    assert(!Overflowed && "Total head samples counter overflowed!");
+  }
+  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/text-format-errors.test

 Tests for instrumentation profile bad encoding.
 
 1- Detect invalid count
 RUN: not llvm-profdata show %p/Inputs/invalid-count-later.proftext 2>&1 | FileCheck %s --check-prefix=INVALID-COUNT-LATER
-RUN: not llvm-profdata merge %p/Inputs/invalid-count-later.proftext %p/Inputs/invalid-count-later.profdata -o %t.out 2>&1 | FileCheck %s --check-prefix=INVALID-COUNT-LATER
+RUN: not llvm-profdata merge %p/Inputs/invalid-count-later.proftext %p/Inputs/invalid-count-later.proftext -o %t.out 2>&1 | FileCheck %s --check-prefix=INVALID-COUNT-LATER
 INVALID-COUNT-LATER: error: {{.*}}invalid-count-later.proftext: Malformed instrumentation profile data
 
 2- Detect bad hash
 RUN: not llvm-profdata show %p/Inputs/bad-hash.proftext 2>&1 | FileCheck %s --check-prefix=BAD-HASH
 RUN: not llvm-profdata merge %p/Inputs/bad-hash.proftext %p/Inputs/bad-hash.proftext -o %t.out 2>&1 | FileCheck %s --check-prefix=BAD-HASH
 BAD-HASH: error: {{.*}}bad-hash.proftext: Malformed instrumentation profile data
 
 3- Detect no counts

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 -weighted-input=1,%p/Inputs/weight-instr-bar.profdata -weighted-input=1,%p/Inputs/weight-instr-foo.profdata -o %t
+RUN: llvm-profdata show -instr -all-functions %t | FileCheck %s -check-prefix=1X_1X_WEIGHT
+RUN: llvm-profdata merge -instr -weighted-input=1,%p/Inputs/weight-instr-bar.profdata %p/Inputs/weight-instr-foo.profdata -o %t
+RUN: llvm-profdata show -instr -all-functions %t | FileCheck %s -check-prefix=1X_1X_WEIGHT
+1X_1X_WEIGHT: Counters:
+1X_1X_WEIGHT-NEXT:   usage:
+1X_1X_WEIGHT-NEXT:     Hash: 0x0000000000000000
+1X_1X_WEIGHT-NEXT:     Counters: 1
+1X_1X_WEIGHT-NEXT:     Function count: 0
+1X_1X_WEIGHT-NEXT:   foo:
+1X_1X_WEIGHT-NEXT:     Hash: 0x000000000000028a
+1X_1X_WEIGHT-NEXT:     Counters: 3
+1X_1X_WEIGHT-NEXT:     Function count: 866988873
+1X_1X_WEIGHT-NEXT:   bar:
+1X_1X_WEIGHT-NEXT:     Hash: 0x000000000000028a
+1X_1X_WEIGHT-NEXT:     Counters: 3
+1X_1X_WEIGHT-NEXT:     Function count: 866988873
+1X_1X_WEIGHT-NEXT:   main:
+1X_1X_WEIGHT-NEXT:     Hash: 0x7d31c47ea98f8248
+1X_1X_WEIGHT-NEXT:     Counters: 60
+1X_1X_WEIGHT-NEXT:     Function count: 2
+1X_1X_WEIGHT-NEXT: Functions shown: 4
+1X_1X_WEIGHT-NEXT: Total functions: 4
+1X_1X_WEIGHT-NEXT: Maximum function count: 866988873
+1X_1X_WEIGHT-NEXT: 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 -weighted-input=3,%p/Inputs/weight-instr-bar.profdata -weighted-input=5,%p/Inputs/weight-instr-foo.profdata -o %t
+RUN: llvm-profdata show -instr -all-functions %t | FileCheck %s -check-prefix=3X_5X_WEIGHT
+3X_5X_WEIGHT: Counters:
+3X_5X_WEIGHT-NEXT:   usage:
+3X_5X_WEIGHT-NEXT:     Hash: 0x0000000000000000
+3X_5X_WEIGHT-NEXT:     Counters: 1
+3X_5X_WEIGHT-NEXT:     Function count: 0
+3X_5X_WEIGHT-NEXT:   foo:
+3X_5X_WEIGHT-NEXT:     Hash: 0x000000000000028a
+3X_5X_WEIGHT-NEXT:     Counters: 3
+3X_5X_WEIGHT-NEXT:     Function count: 4334944365
+3X_5X_WEIGHT-NEXT:   bar:
+3X_5X_WEIGHT-NEXT:     Hash: 0x000000000000028a
+3X_5X_WEIGHT-NEXT:     Counters: 3
+3X_5X_WEIGHT-NEXT:     Function count: 2600966619
+3X_5X_WEIGHT-NEXT:   main:
+3X_5X_WEIGHT-NEXT:     Hash: 0x7d31c47ea98f8248
+3X_5X_WEIGHT-NEXT:     Counters: 60
+3X_5X_WEIGHT-NEXT:     Function count: 8
+3X_5X_WEIGHT-NEXT: Functions shown: 4
+3X_5X_WEIGHT-NEXT: Total functions: 4
+3X_5X_WEIGHT-NEXT: Maximum function count: 4334944365
+3X_5X_WEIGHT-NEXT: Maximum internal block count: 1339571480
+
+3- Bad merge: invalid weight
+RUN: not llvm-profdata merge -instr -weighted-input=3,%p/Inputs/weight-instr-bar.profdata -weighted-input=0,%p/Inputs/weight-instr-foo.profdata -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+RUN: not llvm-profdata merge -instr -weighted-input=3,%p/Inputs/weight-instr-bar.profdata -weighted-input=0.75,%p/Inputs/weight-instr-foo.profdata -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+RUN: not llvm-profdata merge -instr -weighted-input=3,%p/Inputs/weight-instr-bar.profdata -weighted-input=-5,%p/Inputs/weight-instr-foo.profdata -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+RUN: not llvm-profdata merge -instr -weighted-input=3,%p/Inputs/weight-instr-bar.profdata -weighted-input=,%p/Inputs/weight-instr-foo.profdata -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+RUN: not llvm-profdata merge -instr -weighted-input=3,%p/Inputs/weight-instr-bar.profdata -weighted-input=%p/Inputs/weight-instr-foo.profdata -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+INVALID_WEIGHT: error: Input weight must be a positive integer.
+
+4- Bad merge: input path does not exist
+RUN: not llvm-profdata merge -instr -weighted-input=3,%p/Inputs/does-not-exist.profdata -weighted-input=2,%p/Inputs/does-not-exist-either.profdata -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_INPUT
+INVALID_INPUT: {{.*}}: {{.*}}does-not-exist.profdata: {{[Nn]}}o such file or directory
+
+5- No inputs
+RUN: not llvm-profdata merge -instr -o %t.out 2>&1 | FileCheck %s -check-prefix=NO_INPUT
+NO_INPUT: {{.*}}: No input files specified. See llvm-profdata{{(\.EXE|\.exe)?}} merge -help

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 -weighted-input=1,%p/Inputs/weight-sample-bar.proftext -weighted-input=1,%p/Inputs/weight-sample-foo.proftext -o - | FileCheck %s -check-prefix=1X_1X_WEIGHT
+RUN: llvm-profdata merge -sample -text -weighted-input=1,%p/Inputs/weight-sample-bar.proftext %p/Inputs/weight-sample-foo.proftext -o - | FileCheck %s -check-prefix=1X_1X_WEIGHT
+1X_1X_WEIGHT: foo:1763288:35327
+1X_1X_WEIGHT-NEXT:  7: 35327
+1X_1X_WEIGHT-NEXT:  8: 35327
+1X_1X_WEIGHT-NEXT:  9: 6930
+1X_1X_WEIGHT-NEXT:  10: 29341
+1X_1X_WEIGHT-NEXT:  11: 11906
+1X_1X_WEIGHT-NEXT:  13: 18185 foo:19531
+1X_1X_WEIGHT-NEXT:  15: 36458
+1X_1X_WEIGHT-NEXT: bar:1772037:35370
+1X_1X_WEIGHT-NEXT:  17: 35370
+1X_1X_WEIGHT-NEXT:  18: 35370
+1X_1X_WEIGHT-NEXT:  19: 7005
+1X_1X_WEIGHT-NEXT:  20: 29407
+1X_1X_WEIGHT-NEXT:  21: 12170
+1X_1X_WEIGHT-NEXT:  23: 18150 bar:19829
+1X_1X_WEIGHT-NEXT:  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 -weighted-input=3,%p/Inputs/weight-sample-bar.proftext -weighted-input=5,%p/Inputs/weight-sample-foo.proftext -o - | FileCheck %s -check-prefix=3X_5X_WEIGHT
+3X_5X_WEIGHT: foo:8816440:176635
+3X_5X_WEIGHT-NEXT:  7: 176635
+3X_5X_WEIGHT-NEXT:  8: 176635
+3X_5X_WEIGHT-NEXT:  9: 34650
+3X_5X_WEIGHT-NEXT:  10: 146705
+3X_5X_WEIGHT-NEXT:  11: 59530
+3X_5X_WEIGHT-NEXT:  13: 90925 foo:97655
+3X_5X_WEIGHT-NEXT:  15: 182290
+3X_5X_WEIGHT-NEXT: bar:5316111:106110
+3X_5X_WEIGHT-NEXT:  17: 106110
+3X_5X_WEIGHT-NEXT:  18: 106110
+3X_5X_WEIGHT-NEXT:  19: 21015
+3X_5X_WEIGHT-NEXT:  20: 88221
+3X_5X_WEIGHT-NEXT:  21: 36510
+3X_5X_WEIGHT-NEXT:  23: 54450 bar:59487
+3X_5X_WEIGHT-NEXT:  25: 109998
+
+3- Bad merge: invalid weight
+RUN: not llvm-profdata merge -sample -weighted-input=3,%p/Inputs/weight-sample-bar.proftext -weighted-input=0,%p/Inputs/weight-sample-foo.proftext -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+RUN: not llvm-profdata merge -sample -weighted-input=3,%p/Inputs/weight-sample-bar.proftext -weighted-input=0.75,%p/Inputs/weight-sample-foo.proftext -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+RUN: not llvm-profdata merge -sample -weighted-input=3,%p/Inputs/weight-sample-bar.proftext -weighted-input=-5,%p/Inputs/weight-sample-foo.proftext -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+RUN: not llvm-profdata merge -sample -weighted-input=3,%p/Inputs/weight-sample-bar.proftext -weighted-input=,%p/Inputs/weight-sample-foo.proftext -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+RUN: not llvm-profdata merge -sample -weighted-input=3,%p/Inputs/weight-sample-bar.proftext -weighted-input=%p/Inputs/weight-sample-foo.proftext -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_WEIGHT
+INVALID_WEIGHT: error: Input weight must be a positive integer.
+
+4- Bad merge: input path does not exist
+RUN: not llvm-profdata merge -sample -weighted-input=3,%p/Inputs/does-not-exist.proftext -weighted-input=2,%p/Inputs/does-not-exist-either.proftext -o %t.out 2>&1 | FileCheck %s -check-prefix=INVALID_INPUT
+INVALID_INPUT: {{.*}}: {{.*}}does-not-exist.proftext: {{[Nn]}}o such file or directory
+
+5- No inputs
+RUN: not llvm-profdata merge -sample -o %t.out 2>&1 | FileCheck %s -check-prefix=NO_INPUT
+NO_INPUT: {{.*}}: No input files specified. See llvm-profdata{{(\.EXE|\.exe)?}} merge -help

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/Errc.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 <algorithm>
+#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 = "") {
   errs() << "error: ";
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 int merge_main(int argc, const char *argv[]) {
-  cl::list<std::string> Inputs(cl::Positional, cl::Required, cl::OneOrMore,
-                               cl::desc("<filenames...>"));
+static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) {
+  StringRef WeightStr, FileName;
+  std::tie(WeightStr, FileName) = WeightedFilename.split(',');
+
+  uint64_t Weight;
+  if (WeightStr.getAsInteger(10, Weight) || Weight < 1)
+    exitWithError("Input weight must be a positive integer.");
+
+  if (!sys::fs::exists(FileName))
+    exitWithErrorCode(make_error_code(errc::no_such_file_or_directory),
+                      FileName);
+
+  return WeightedFile(FileName, Weight);
+}
 
+static int merge_main(int argc, const char *argv[]) {
+  cl::list<std::string> InputFilenames(cl::Positional,
+                                       cl::desc("<filename...>"));
+  cl::list<std::string> WeightedInputFilenames("weighted-input",
+                                               cl::desc("<weight>,<filename>"));
   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");
 
+  if (InputFilenames.empty() && WeightedInputFilenames.empty())
+    exitWithError("No input files specified. See " +
+                  sys::path::filename(argv[0]) + " -help");
+
+  WeightedFileVector WeightedInputs;
+  for (StringRef Filename : InputFilenames)
+    WeightedInputs.push_back(WeightedFile(Filename, 1));
+  for (StringRef WeightedFilename : WeightedInputFilenames)
+    WeightedInputs.push_back(parseWeightedFile(WeightedFilename));
+
   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_icall_data_merge1_saturation) {
   InstrProfRecord Record2("caller", 0x1234, {Max});
   InstrProfRecord Record3("callee1", 0x1235, {3, 4});
 
   Record1.reserveSites(IPVK_IndirectCallTarget, 1);
   InstrProfValueData VD1[] = {{(uint64_t) "callee1", 1}};
   Record1.addValueData(IPVK_IndirectCallTarget, 0, VD1, 1, nullptr);
 
   Record2.reserveSites(IPVK_IndirectCallTarget, 1);
-  InstrProfValueData VD2[] = {{(uint64_t) "callee1", Max}};
+  // FIXME: Improve handling of counter overflow. ValueData asserts on overflow.
+  //  InstrProfValueData VD2[] = {{(uint64_t) "callee1", Max}};
+  InstrProfValueData VD2[] = {{(uint64_t) "callee1", 1}};
   Record2.addValueData(IPVK_IndirectCallTarget, 0, VD2, 1, nullptr);
 
   Writer.addRecord(std::move(Record1));
   Writer.addRecord(std::move(Record2));
   Writer.addRecord(std::move(Record3));
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   // Verify saturation of counts.
   ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
   ASSERT_TRUE(NoError(R.getError()));
 
   ASSERT_EQ(Max, R.get().Counts[0]);
 
   ASSERT_EQ(1U, R.get().getNumValueSites(IPVK_IndirectCallTarget));
   std::unique_ptr<InstrProfValueData[]> VD =
           R.get().getValueForSite(IPVK_IndirectCallTarget, 0);
   ASSERT_EQ(StringRef("callee1"), StringRef((const char *)VD[0].Value, 7));
-  ASSERT_EQ(Max, VD[0].Count);
+
+  // FIXME: Improve handling of counter overflow. ValueData asserts on overflow.
+  //  ASSERT_EQ(Max, VD[0].Count);
+  ASSERT_EQ(2U, VD[0].Count);
 }
 
 // Synthesize runtime value profile data.
 ValueProfNode Site1Values[5] = {{{uint64_t("callee1"), 400}, &Site1Values[1]},
                                 {{uint64_t("callee2"), 1000}, &Site1Values[2]},
                                 {{uint64_t("callee3"), 500}, &Site1Values[3]},
                                 {{uint64_t("callee4"), 300}, &Site1Values[4]},
                                 {{uint64_t("callee5"), 100}, 0}};
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