[CSSPGO][CSProfileConverter] Remove call target samples when including callee samples into caller.

[hoy]

Summary

When a flat CS profile is converted to a nested profile, the call target samples for inlined callee contexts are left over in the callsite target map. This could cause indirect call promotion to function improperly. One issue is that the inlined callsites are treated with double amount of samples. The other is the inlined callsites are reconsidered for subsequent PGO ICP.

I'm fixing this by excluding call targets from the callsite for inlined targets. While fixing this I found that callsite target sum and the number of body samples for that callsite could be mismatched. D122609: [llvm-profgen] Update callsite body samples by summing up all call target samples. has an explanation and a fix for that on llvm-profgen side. For now I'm tolerating it in this change.

[hoy]

Updating D125266: [CSSPGO][CSProfileConverter] Remove call target samples when including callee samples into caller.

[wenlei]

When a flat CS profile is converted to a nested profile, the call target samples for inlined callee contexts are left over in the callsite target map.

Good catch.. That is also not consistent with AutoFDO profile -- a callee should be in either call site sample or target map of body sample, but not both.

llvm/include/llvm/ProfileData/SampleProf.h

378

The asymmetricity between removeCalledTarget and addCalledTarget can be confusing. We're reducing NumSamples in removeCalledTarget, but we are not adding removeCalledTarget in addCalledTarget. Two questions, 1) should NumSamples include target counts, and are we doing that consistently? 2) Any ways to make them the two functions consistent?

383

You used optional instead relying on zero to indicate no removal here because there could be count be zero count returned due to mismatch but removal is still happening?

llvm/lib/ProfileData/SampleProf.cpp

527

nit: subtractTotalSamples to be clear.

[hoy]

llvm/include/llvm/ProfileData/SampleProf.h

378

NumSamples and target counts are computed separately in llvm-profgen, one is based on lbr ranges while the other is based on branch samples. So they do not have any connection on the profile generator side.

I guess we can separate removeSamples out of removeCalledTarget to be consistent. The same would also be needed on the FunctionSample side. Maybe just rename removeCalledTarget to removeCalledTargetAndBodySamples? For now they should always be reduced together.

383

Yes, it is to identify mismatch or zero-count call targets. The latter should be very rare though.

llvm/lib/ProfileData/SampleProf.cpp

527

Done.

[wenlei]

llvm/include/llvm/ProfileData/SampleProf.h

378

Ok, now I see that they're added separately. I'm wondering what is the definition of NumSamples. If the two don't have connection and NumSamples is samples for this location, and call target count is the count for specific call targets, then they should be changed independently.

Here changing the call/callee representation from CallTargets to nested FunctionSamples shouldn't change the value of NumSamples because the we would still derived the same value from the same ranges?

[hoy]

llvm/include/llvm/ProfileData/SampleProf.h

378

By no connection I mean how they are generated in llvm-profgen and used in the compiler technically. But logically NumSamples should be the sum of all target counts. It reflects the the execution count of the callsite. Removing one target means the callsite won't be executed as many times as before. The reduced count will be instead reflected on another code path that promotes the indirect callsite. Annotating block frequency based on the original callsite count (due to the max operation) could be misleading.

[wenlei]

llvm/include/llvm/ProfileData/SampleProf.h

378

Followed up offline. So the key is that NumSamples of call site BodySample only contains execution counts for not inline calls. And nest profile implies inlining, so changing representation from call target to nest profile does need to reduce NumSample for call site.. So it's good here.

The asymmetricity in naming and what they do is still less than ideal though. Perhaps for SampleRecord we can just make it consistent by having one removeCalledTarget that only removes target, and, and one removeBodySamples that only reduces NumSamples.

For FunctionSamples, removeCalledTarget-> removeCalledTargetAndBodySample?

[hoy]

llvm/include/llvm/ProfileData/SampleProf.h

378

Sounds good. I'm also removing the use of Optional, instead using zero count to simplify the logic.

[hoy]

Updating D125266: [CSSPGO][CSProfileConverter] Remove call target samples when including callee samples into caller.

[wenlei]

lgtm except nits.

llvm/include/llvm/ProfileData/SampleProf.h

728

nit: now that we have a removeSamples, name this removeTotalSamples.

llvm/lib/ProfileData/SampleProf.cpp

27

Is this needed?

[hoy]

llvm/include/llvm/ProfileData/SampleProf.h

728

Sounds good.

llvm/lib/ProfileData/SampleProf.cpp

27

Good catch. It's not. It was automatically added by my editor,

[hoy]

Updating D125266: [CSSPGO][CSProfileConverter] Remove call target samples when including callee samples into caller.

llvm/include/llvm/ProfileData/SampleProf.h

public:
   /// around unsigned integers.
   sampleprof_error addSamples(uint64_t S, uint64_t Weight = 1) {
     bool Overflowed;
     NumSamples = SaturatingMultiplyAdd(S, Weight, NumSamples, &Overflowed);
     return Overflowed ? sampleprof_error::counter_overflow
                       : sampleprof_error::success;
   }
 
+  /// Decrease the number of samples for this record by \p S. Return the amout
+  /// of samples actually decreased.
+  uint64_t removeSamples(uint64_t S) {
+    if (S > NumSamples)
+      S = NumSamples;
+    NumSamples -= S;
+    return 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.
   sampleprof_error addCalledTarget(StringRef F, uint64_t S,
                                    uint64_t Weight = 1) {
     uint64_t &TargetSamples = CallTargets[F];
     bool Overflowed;
     TargetSamples =
         SaturatingMultiplyAdd(S, Weight, TargetSamples, &Overflowed);
     return Overflowed ? sampleprof_error::counter_overflow
                       : sampleprof_error::success;
   }
 
+  /// Remove called function from the call target map. Return the target sample
+  /// count of the called function.
+  uint64_t removeCalledTarget(StringRef F) {
+    uint64_t Count = 0;
+    auto I = CallTargets.find(F);
+    if (I != CallTargets.end()) {
+      Count = I->second;
+      CallTargets.erase(I);
+    }
+    return Count;
+  }
+
   /// Return true if this sample record contains function calls.
   bool hasCalls() const { return !CallTargets.empty(); }
 
   uint64_t getSamples() const { return NumSamples; }
   const CallTargetMap &getCallTargets() const { return CallTargets; }
   const SortedCallTargetSet getSortedCallTargets() const {
     return SortCallTargets(CallTargets);
   }
 
   /// Sort call targets in descending order of call frequency.
   static const SortedCallTargetSet SortCallTargets(const CallTargetMap &Targets) {
public:
   sampleprof_error addTotalSamples(uint64_t Num, uint64_t Weight = 1) {
     bool Overflowed;
     TotalSamples =
         SaturatingMultiplyAdd(Num, Weight, TotalSamples, &Overflowed);
     return Overflowed ? sampleprof_error::counter_overflow
                       : sampleprof_error::success;
   }
 
+  void removeTotalSamples(uint64_t Num) {
+    if (TotalSamples < Num)
+      TotalSamples = 0;
+    else
+      TotalSamples -= Num;
+  }
+
   void setTotalSamples(uint64_t Num) { TotalSamples = Num; }
 
   sampleprof_error addHeadSamples(uint64_t Num, uint64_t Weight = 1) {
     bool Overflowed;
     TotalHeadSamples =
         SaturatingMultiplyAdd(Num, Weight, TotalHeadSamples, &Overflowed);
     return Overflowed ? sampleprof_error::counter_overflow
                       : sampleprof_error::success;
   }
 
   sampleprof_error addBodySamples(uint32_t LineOffset, uint32_t Discriminator,
                                   uint64_t Num, uint64_t Weight = 1) {
     return BodySamples[LineLocation(LineOffset, Discriminator)].addSamples(
         Num, Weight);
   }
 
   sampleprof_error addCalledTargetSamples(uint32_t LineOffset,
                                           uint32_t Discriminator,
                                           StringRef FName, uint64_t Num,
                                           uint64_t Weight = 1) {
     return BodySamples[LineLocation(LineOffset, Discriminator)].addCalledTarget(
         FName, Num, Weight);
   }
 
+  // Remove a call target and decrease the body sample correspondingly. Return
+  // the number of body samples actually decreased.
+  uint64_t removeCalledTargetAndBodySample(uint32_t LineOffset,
+                                           uint32_t Discriminator,
+                                           StringRef FName) {
+    uint64_t Count = 0;
+    auto I = BodySamples.find(LineLocation(LineOffset, Discriminator));
+    if (I != BodySamples.end()) {
+      Count = I->second.removeCalledTarget(FName);
+      Count = I->second.removeSamples(Count);
+      if (!I->second.getSamples())
+        BodySamples.erase(I);
+    }
+    return Count;
+  }
+
   sampleprof_error addBodySamplesForProbe(uint32_t Index, uint64_t Num,
                                           uint64_t Weight = 1) {
     SampleRecord S;
     S.addSamples(Num, Weight);
     return BodySamples[LineLocation(Index, 0)].merge(S, Weight);
   }
 
   // Accumulate all body samples to set total samples.

llvm/lib/ProfileData/SampleProf.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <system_error>
 
 using namespace llvm;
 using namespace sampleprof;
 
 static cl::opt<uint64_t> ProfileSymbolListCutOff(
     "profile-symbol-list-cutoff", cl::Hidden, cl::init(-1), cl::ZeroOrMore,
     cl::desc("Cutoff value about how many symbols in profile symbol list "
              "will be used. This is very useful for performance debugging"));
 
for (auto &It : Node.AllChildFrames) {
     SampleContext OrigChildContext = ChildProfile->getContext();
     // Reset the child context to be contextless.
     ChildProfile->getContext().setName(OrigChildContext.getName());
     if (NodeProfile) {
       // Add child profile to the callsite profile map.
       auto &SamplesMap = NodeProfile->functionSamplesAt(ChildNode.CallSiteLoc);
       SamplesMap.emplace(OrigChildContext.getName().str(), *ChildProfile);
       NodeProfile->addTotalSamples(ChildProfile->getTotalSamples());
+      // Remove the corresponding body sample for the callsite and update the
+      // total weight.
+      auto Count = NodeProfile->removeCalledTargetAndBodySample(
+          ChildNode.CallSiteLoc.LineOffset, ChildNode.CallSiteLoc.Discriminator,
+          OrigChildContext.getName());
+      NodeProfile->removeTotalSamples(Count);
     }
 
     // Separate child profile to be a standalone profile, if the current parent
     // profile doesn't exist. This is a duplicating operation when the child
     // profile is already incorporated into the parent which is still useful and
     // thus done optionally. It is seen that duplicating context profiles into
     // base profiles improves the code quality for thinlto build by allowing a
     // profile in the prelink phase for to-be-fully-inlined functions.
     if (!NodeProfile) {

llvm/test/tools/llvm-profdata/cs-sample-nested-profile.test

 RUN: llvm-profdata merge --sample --text -output=%t.proftext %S/Inputs/cs-sample-preinline.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=0
 RUN: FileCheck %s < %t.proftext --match-full-lines --strict-whitespace
 RUN: llvm-profdata merge --sample --text -output=%t.probe.proftext %S/Inputs/cs-sample-preinline-probe.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=0
 RUN: FileCheck %s < %t.probe.proftext --match-full-lines --strict-whitespace -check-prefix=PROBE
 RUN: llvm-profdata merge --sample --extbinary -output=%t.profbin %S/Inputs/cs-sample-preinline.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=0
 RUN: llvm-profdata merge --sample --text -output=%t2.proftext %t.profbin
 RUN: FileCheck %s < %t2.proftext --match-full-lines --strict-whitespace
 RUN: llvm-profdata show --sample -show-sec-info-only %t.profbin | FileCheck %s -check-prefix=PREINLINE
 RUN: llvm-profdata merge --sample --text -output=%t3.proftext %S/Inputs/cs-sample-preinline.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=1
 RUN: FileCheck %s < %t3.proftext --match-full-lines --strict-whitespace -check-prefix=RECOUNT
 RUN: llvm-profdata merge --sample --extbinary -output=%t2.profbin %S/Inputs/cs-sample-preinline.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=1
 RUN: llvm-profdata show -sample -detailed-summary %S/Inputs/cs-sample-preinline.proftext | FileCheck %s -check-prefix=SUMMARY
-RUN: llvm-profdata show -sample -detailed-summary %t2.profbin | FileCheck %s -check-prefix=SUMMARY
-RUN: llvm-profdata show -sample -detailed-summary %t3.proftext | FileCheck %s -check-prefix=SUMMARY
+RUN: llvm-profdata show -sample -detailed-summary %t2.profbin | FileCheck %s -check-prefix=SUMMARY-NEST
+RUN: llvm-profdata show -sample -detailed-summary %t3.proftext | FileCheck %s -check-prefix=SUMMARY-NEST
 
 
-; CHECK:main:1968679:12
+; CHECK:main:1968621:12
 ; CHECK-NEXT: 2: 24
-; CHECK-NEXT: 3: 28 _Z5funcAi:18
-; CHECK-NEXT: 3.1: 28 _Z5funcBi:30
-; CHECK-NEXT: 3: _Z5funcAi:1467398
+; CHECK-NEXT: 3: 17 _Z5funcAi:7
+; CHECK-NEXT: 3.1: 10 _Z5funcBi:11
+; CHECK-NEXT: 3: _Z5funcAi:1467388
 ; CHECK-NEXT:  0: 10
-; CHECK-NEXT:  1: 10 _Z8funcLeafi:11
 ; CHECK-NEXT:  3: 24
 ; CHECK-NEXT:  1: _Z8funcLeafi:1467299
 ; CHECK-NEXT:   0: 6
 ; CHECK-NEXT:   1: 6
 ; CHECK-NEXT:   3: 287884
 ; CHECK-NEXT:   4: 287864 _Z3fibi:315608
 ; CHECK-NEXT:   15: 23
 ; CHECK-NEXT:   !Attributes: 2
 ; CHECK-NEXT:  !Attributes: 2
-; CHECK-NEXT: 3.1: _Z5funcBi:500973
+; CHECK-NEXT: 3.1: _Z5funcBi:500954
 ; CHECK-NEXT:  0: 19
-; CHECK-NEXT:  1: 19 _Z8funcLeafi:20
 ; CHECK-NEXT:  3: 12
 ; CHECK-NEXT:  1: _Z8funcLeafi:500853
 ; CHECK-NEXT:   0: 15
 ; CHECK-NEXT:   1: 15
 ; CHECK-NEXT:   3: 74946
 ; CHECK-NEXT:   4: 74941 _Z3fibi:82359
 ; CHECK-NEXT:   10: 23324
 ; CHECK-NEXT:   11: 23327 _Z3fibi:25228
 ; CHECK-NEXT:   15: 11
 ; CHECK-NEXT:   !Attributes: 2
 ; CHECK-NEXT:  !Attributes: 2
 ; CHECK-NEXT:_Z5funcBi:240:13
 ; CHECK-NEXT: 0: 13
 ; CHECK-NEXT: 1: 13
 
 
-
-; RECOUNT:main:1968679:12
+; RECOUNT:main:1968621:12
 ; RECOUNT-NEXT: 2: 24
-; RECOUNT-NEXT: 3: 28 _Z5funcAi:18
-; RECOUNT-NEXT: 3.1: 28 _Z5funcBi:30
-; RECOUNT-NEXT: 3: _Z5funcAi:1467398
+; RECOUNT-NEXT: 3: 17 _Z5funcAi:7
+; RECOUNT-NEXT: 3.1: 10 _Z5funcBi:11
+; RECOUNT-NEXT: 3: _Z5funcAi:1467388
 ; RECOUNT-NEXT:  0: 10
-; RECOUNT-NEXT:  1: 10 _Z8funcLeafi:11
 ; RECOUNT-NEXT:  3: 24
 ; RECOUNT-NEXT:  1: _Z8funcLeafi:1467299
 ; RECOUNT-NEXT:   0: 6
 ; RECOUNT-NEXT:   1: 6
 ; RECOUNT-NEXT:   3: 287884
 ; RECOUNT-NEXT:   4: 287864 _Z3fibi:315608
 ; RECOUNT-NEXT:   15: 23
 ; RECOUNT-NEXT:   !Attributes: 6
 ; RECOUNT-NEXT:  !Attributes: 6
-; RECOUNT-NEXT: 3.1: _Z5funcBi:500973
+; RECOUNT-NEXT: 3.1: _Z5funcBi:500954
 ; RECOUNT-NEXT:  0: 19
-; RECOUNT-NEXT:  1: 19 _Z8funcLeafi:20
 ; RECOUNT-NEXT:  3: 12
 ; RECOUNT-NEXT:  1: _Z8funcLeafi:500853
 ; RECOUNT-NEXT:   0: 15
 ; RECOUNT-NEXT:   1: 15
 ; RECOUNT-NEXT:   3: 74946
 ; RECOUNT-NEXT:   4: 74941 _Z3fibi:82359
 ; RECOUNT-NEXT:   10: 23324
 ; RECOUNT-NEXT:   11: 23327 _Z3fibi:25228
 ; RECOUNT-NEXT:   15: 11
 ; RECOUNT-NEXT:   !Attributes: 6
 ; RECOUNT-NEXT:  !Attributes: 6
 ; RECOUNT-NEXT:_Z8funcLeafi:1968152:31
 ; RECOUNT-NEXT: 0: 21
 ; RECOUNT-NEXT: 1: 21
 ; RECOUNT-NEXT: 3: 362830
 ; RECOUNT-NEXT: 4: 362805 _Z3fibi:397967
 ; RECOUNT-NEXT: 10: 23324
 ; RECOUNT-NEXT: 11: 23327 _Z3fibi:25228
 ; RECOUNT-NEXT: 15: 34
 ; RECOUNT-NEXT: !Attributes: 2
-; RECOUNT-NEXT:_Z5funcAi:1467398:11
+; RECOUNT-NEXT:_Z5funcAi:1467388:11
 ; RECOUNT-NEXT: 0: 10
-; RECOUNT-NEXT: 1: 10 _Z8funcLeafi:11
 ; RECOUNT-NEXT: 3: 24
 ; RECOUNT-NEXT: 1: _Z8funcLeafi:1467299
 ; RECOUNT-NEXT:  0: 6
 ; RECOUNT-NEXT:  1: 6
 ; RECOUNT-NEXT:  3: 287884
 ; RECOUNT-NEXT:  4: 287864 _Z3fibi:315608
 ; RECOUNT-NEXT:  15: 23
 ; RECOUNT-NEXT:  !Attributes: 6
 ; RECOUNT-NEXT: !Attributes: 2
-; RECOUNT-NEXT:_Z5funcBi:501213:32
+; RECOUNT-NEXT:_Z5funcBi:501194:32
 ; RECOUNT-NEXT: 0: 32
-; RECOUNT-NEXT: 1: 32 _Z8funcLeafi:20
+; RECOUNT-NEXT: 1: 13
 ; RECOUNT-NEXT: 3: 12
 ; RECOUNT-NEXT: 1: _Z8funcLeafi:500853
 ; RECOUNT-NEXT:  0: 15
 ; RECOUNT-NEXT:  1: 15
 ; RECOUNT-NEXT:  3: 74946
 ; RECOUNT-NEXT:  4: 74941 _Z3fibi:82359
 ; RECOUNT-NEXT:  10: 23324
 ; RECOUNT-NEXT:  11: 23327 _Z3fibi:25228
 ; RECOUNT-NEXT:  15: 11
 ; RECOUNT-NEXT:  !Attributes: 6
 
-; PROBE:main:1968679:12
+; PROBE:main:1968621:12
 ; PROBE-NEXT: 2: 24
-; PROBE-NEXT: 3: 28 _Z5funcAi:18
-; PROBE-NEXT: 3.1: 28 _Z5funcBi:30
-; PROBE-NEXT: 3: _Z5funcAi:1467398
+; PROBE-NEXT: 3: 17 _Z5funcAi:7
+; PROBE-NEXT: 3.1: 10 _Z5funcBi:11
+; PROBE-NEXT: 3: _Z5funcAi:1467388
 ; PROBE-NEXT:  0: 10
-; PROBE-NEXT:  1: 10 _Z8funcLeafi:11
 ; PROBE-NEXT:  3: 24
 ; PROBE-NEXT:  1: _Z8funcLeafi:1467299
 ; PROBE-NEXT:   0: 6
 ; PROBE-NEXT:   1: 6
 ; PROBE-NEXT:   3: 287884
 ; PROBE-NEXT:   4: 287864 _Z3fibi:315608
 ; PROBE-NEXT:   15: 23
 ; PROBE-NEXT:   !CFGChecksum: 281479271677951
 ; PROBE-NEXT:   !Attributes: 2
 ; PROBE-NEXT:  !CFGChecksum: 844530426352218
 ; PROBE-NEXT:  !Attributes: 2
-; PROBE-NEXT: 3.1: _Z5funcBi:500973
+; PROBE-NEXT: 3.1: _Z5funcBi:500954
 ; PROBE-NEXT:  0: 19
-; PROBE-NEXT:  1: 19 _Z8funcLeafi:20
 ; PROBE-NEXT:  3: 12
 ; PROBE-NEXT:  1: _Z8funcLeafi:500853
 ; PROBE-NEXT:   0: 15
 ; PROBE-NEXT:   1: 15
 ; PROBE-NEXT:   3: 74946
 ; PROBE-NEXT:   4: 74941 _Z3fibi:82359
 ; PROBE-NEXT:   10: 23324
 ; PROBE-NEXT:   11: 23327 _Z3fibi:25228

 ; SUMMARY-NEXT: 2 blocks with count >= 362805 account for 80 percentage of the total counts.
 ; SUMMARY-NEXT: 2 blocks with count >= 362805 account for 90 percentage of the total counts.
 ; SUMMARY-NEXT: 3 blocks with count >= 23327 account for 95 percentage of the total counts.
 ; SUMMARY-NEXT: 4 blocks with count >= 23324 account for 99 percentage of the total counts.
 ; SUMMARY-NEXT: 4 blocks with count >= 23324 account for 99.9 percentage of the total counts.
 ; SUMMARY-NEXT: 11 blocks with count >= 24 account for 99.99 percentage of the total counts.
 ; SUMMARY-NEXT: 16 blocks with count >= 10 account for 99.999 percentage of the total counts.
 ; SUMMARY-NEXT: 16 blocks with count >= 10 account for 99.9999 percentage of the total counts.
+
+
+; SUMMARY-NEST:      Total functions: 4
+; SUMMARY-NEST-NEXT: Maximum function count: 32
+; SUMMARY-NEST-NEXT: Maximum block count: 362830
+; SUMMARY-NEST-NEXT: Total number of blocks: 15
+; SUMMARY-NEST-NEXT: Total count: 772504
+; SUMMARY-NEST-NEXT: Detailed summary:
+; SUMMARY-NEST-NEXT: 1 blocks with count >= 362830 account for 1 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 1 blocks with count >= 362830 account for 10 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 1 blocks with count >= 362830 account for 20 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 1 blocks with count >= 362830 account for 30 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 1 blocks with count >= 362830 account for 40 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 2 blocks with count >= 362805 account for 50 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 2 blocks with count >= 362805 account for 60 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 2 blocks with count >= 362805 account for 70 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 2 blocks with count >= 362805 account for 80 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 2 blocks with count >= 362805 account for 90 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 3 blocks with count >= 23327 account for 95 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 4 blocks with count >= 23324 account for 99 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 4 blocks with count >= 23324 account for 99.9 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 10 blocks with count >= 21 account for 99.99 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 15 blocks with count >= 10 account for 99.999 percentage of the total counts.
+; SUMMARY-NEST-NEXT: 15 blocks with count >= 10 account for 99.9999 percentage of the total counts.

llvm/test/tools/llvm-profgen/cs-preinline.test

 ; CHECK-NO-PREINL-NEXT: 1: 14
 ; CHECK-NO-PREINL-NEXT: !Attributes: 1
 
 ; CHECK-TRIM-NOT: [foo]:309:0
 ; CHECK-TRIM:[foo:3.1 @ bar]:84:0
 ; CHECK-TRIM-NEXT: 1: 14
 ; CHECK-TRIM-NEXT: !Attributes: 3
 
-; CHECK-PREINL-NEST:     foo:393:0
+; CHECK-PREINL-NEST:     foo:379:0
 ; CHECK-PREINL-NEST-NEXT: 2.1: 14
 ; CHECK-PREINL-NEST-NEXT: 3: 15
-; CHECK-PREINL-NEST-NEXT: 3.1: 14 bar:14
 ; CHECK-PREINL-NEST-NEXT: 3.2: 1
 ; CHECK-PREINL-NEST-NEXT: 65526: 14
 ; CHECK-PREINL-NEST-NEXT: 3.1: bar:84
 ; CHECK-PREINL-NEST-NEXT:  1: 14
 ; CHECK-PREINL-NEST-NEXT:  !Attributes: 3
 
 
 ; CHECK-PREINL-FLAG: ProfileSummarySection {{.*}} Flags: {{{.*}}preInlined}