[CSSPGO] Rename the field of SampleContextFrame

[wlei]

Summary

Rename CallerName/Callsite to FuncName/Location

[wenlei]

lgtm, thanks for the cleanup.

llvm/include/llvm/ProfileData/SampleProf.h

 
 // Attribute of context associated with FunctionSamples
 enum ContextAttributeMask {
   ContextNone = 0x0,
   ContextWasInlined = 0x1,      // Leaf of context was inlined in previous build
   ContextShouldBeInlined = 0x2, // Leaf of context should be inlined
 };
 
-// Represents a callsite with caller function name and line location
+// Represents a context frame with function name and line location
 struct SampleContextFrame {
-  StringRef CallerName;
-  LineLocation Callsite;
+  StringRef FuncName;
+  LineLocation Location;
 
-  SampleContextFrame() : Callsite(0, 0) {}
+  SampleContextFrame() : Location(0, 0) {}
 
-  SampleContextFrame(StringRef CallerName, LineLocation Callsite)
-      : CallerName(CallerName), Callsite(Callsite) {}
+  SampleContextFrame(StringRef FuncName, LineLocation Location)
+      : FuncName(FuncName), Location(Location) {}
 
   bool operator==(const SampleContextFrame &That) const {
-    return Callsite == That.Callsite && CallerName == That.CallerName;
+    return Location == That.Location && FuncName == That.FuncName;
   }
 
   bool operator!=(const SampleContextFrame &That) const {
     return !(*this == That);
   }
 
   std::string toString(bool OutputLineLocation) const {
     std::ostringstream OContextStr;
-    OContextStr << CallerName.str();
+    OContextStr << FuncName.str();
     if (OutputLineLocation) {
-      OContextStr << ":" << Callsite.LineOffset;
-      if (Callsite.Discriminator)
-        OContextStr << "." << Callsite.Discriminator;
+      OContextStr << ":" << Location.LineOffset;
+      if (Location.Discriminator)
+        OContextStr << "." << Location.Discriminator;
     }
     return OContextStr.str();
   }
 };
 
 static inline hash_code hash_value(const SampleContextFrame &arg) {
-  return hash_combine(arg.CallerName, arg.Callsite.LineOffset,
-                      arg.Callsite.Discriminator);
+  return hash_combine(arg.FuncName, arg.Location.LineOffset,
+                      arg.Location.Discriminator);
 }
 
 using SampleContextFrameVector = SmallVector<SampleContextFrame, 10>;
 using SampleContextFrames = ArrayRef<SampleContextFrame>;
 
 struct SampleContextFrameHash {
   uint64_t operator()(const SampleContextFrameVector &S) const {
     return hash_combine_range(S.begin(), S.end());
assert(FullContext.empty() &&
            "setName should only be called for non-CS profile");
     Name = FunctionName;
   }
 
   void setContext(SampleContextFrames Context,
                   ContextStateMask CState = RawContext) {
     assert(CState != UnknownContext);
     FullContext = Context;
-    Name = Context.back().CallerName;
+    Name = Context.back().FuncName;
     State = CState;
   }
 
   bool operator==(const SampleContext &That) const {
     return State == That.State && Name == That.Name &&
            FullContext == That.FullContext;
   }
 
   bool operator!=(const SampleContext &That) const { return !(*this == That); }
 
   bool operator<(const SampleContext &That) const {
     if (State != That.State)
       return State < That.State;
 
     if (!hasContext()) {
       return (Name.compare(That.Name)) == -1;
     }
 
     uint64_t I = 0;
     while (I < std::min(FullContext.size(), That.FullContext.size())) {
       auto &Context1 = FullContext[I];
       auto &Context2 = That.FullContext[I];
-      auto V = Context1.CallerName.compare(Context2.CallerName);
+      auto V = Context1.FuncName.compare(Context2.FuncName);
       if (V)
         return V == -1;
-      if (Context1.Callsite != Context2.Callsite)
-        return Context1.Callsite < Context2.Callsite;
+      if (Context1.Location != Context2.Location)
+        return Context1.Location < Context2.Location;
       I++;
     }
 
     return FullContext.size() < That.FullContext.size();
   }
 
   struct Hash {
     uint64_t operator()(const SampleContext &Context) const {
       return Context.getHashCode();
     }
   };
 
   bool IsPrefixOf(const SampleContext &That) const {
     auto ThisContext = FullContext;
     auto ThatContext = That.FullContext;
     if (ThatContext.size() < ThisContext.size())
       return false;
     ThatContext = ThatContext.take_front(ThisContext.size());
     // Compare Leaf frame first
-    if (ThisContext.back().CallerName != ThatContext.back().CallerName)
+    if (ThisContext.back().FuncName != ThatContext.back().FuncName)
       return false;
     // Compare leading context
     return ThisContext.drop_back() == ThatContext.drop_back();
   }
 
 private:
   /// Mangled name of the function.
   StringRef Name;

llvm/lib/ProfileData/SampleProfWriter.cpp

std::error_code SampleProfileWriterExtBinaryBase::writeCSNameTableSection() {
 
   auto &OS = *OutputStream;
   encodeULEB128(OrderedContexts.size(), OS);
   support::endian::Writer Writer(OS, support::little);
   for (auto Context : OrderedContexts) {
     auto Frames = Context.getContextFrames();
     encodeULEB128(Frames.size(), OS);
     for (auto &Callsite : Frames) {
-      if (std::error_code EC = writeNameIdx(Callsite.CallerName))
+      if (std::error_code EC = writeNameIdx(Callsite.FuncName))
         return EC;
-      encodeULEB128(Callsite.Callsite.LineOffset, OS);
-      encodeULEB128(Callsite.Callsite.Discriminator, OS);
+      encodeULEB128(Callsite.Location.LineOffset, OS);
+      encodeULEB128(Callsite.Location.Discriminator, OS);
     }
   }
 
   return sampleprof_error::success;
 }
 
 std::error_code
 SampleProfileWriterExtBinaryBase::writeProfileSymbolListSection() {
for (const auto &FS : J.second) {
       addNames(CalleeSamples);
     }
 }
 
 void SampleProfileWriterExtBinaryBase::addContext(
     const SampleContext &Context) {
   if (Context.hasContext()) {
     for (auto &Callsite : Context.getContextFrames())
-      SampleProfileWriterBinary::addName(Callsite.CallerName);
+      SampleProfileWriterBinary::addName(Callsite.FuncName);
     CSNameTable.insert(std::make_pair(Context, 0));
   } else {
     SampleProfileWriterBinary::addName(Context.getName());
   }
 }
 
 void SampleProfileWriterBinary::stablizeNameTable(
     MapVector<StringRef, uint32_t> &NameTable, std::set<StringRef> &V) {

llvm/lib/Transforms/IPO/SampleContextTracker.cpp

 SampleContextTracker::getOrCreateContextPath(const SampleContext &Context,
                                              bool AllowCreate) {
   ContextTrieNode *ContextNode = &RootContext;
   LineLocation CallSiteLoc(0, 0);
 
   for (auto &Callsite : Context.getContextFrames()) {
     // Create child node at parent line/disc location
     if (AllowCreate) {
-      ContextNode = ContextNode->getOrCreateChildContext(CallSiteLoc,
-                                                         Callsite.CallerName);
+      ContextNode =
+          ContextNode->getOrCreateChildContext(CallSiteLoc, Callsite.FuncName);
     } else {
       ContextNode =
-          ContextNode->getChildContext(CallSiteLoc, Callsite.CallerName);
+          ContextNode->getChildContext(CallSiteLoc, Callsite.FuncName);
     }
-    CallSiteLoc = Callsite.Callsite;
+    CallSiteLoc = Callsite.Location;
   }
 
   assert((!AllowCreate || ContextNode) &&
          "Node must exist if creation is allowed");
   return ContextNode;
 }
 
 ContextTrieNode *SampleContextTracker::getTopLevelContextNode(StringRef FName) {

llvm/tools/llvm-profgen/CallContext.h

 #include <sstream>
 #include <string>
 #include <vector>
 
 namespace llvm {
 namespace sampleprof {
 
 inline std::string getCallSite(const SampleContextFrame &Callsite) {
-  std::string CallsiteStr = Callsite.CallerName.str();
+  std::string CallsiteStr = Callsite.FuncName.str();
   CallsiteStr += ":";
-  CallsiteStr += Twine(Callsite.Callsite.LineOffset).str();
-  if (Callsite.Callsite.Discriminator > 0) {
+  CallsiteStr += Twine(Callsite.Location.LineOffset).str();
+  if (Callsite.Location.Discriminator > 0) {
     CallsiteStr += ".";
-    CallsiteStr += Twine(Callsite.Callsite.Discriminator).str();
+    CallsiteStr += Twine(Callsite.Location.Discriminator).str();
   }
   return CallsiteStr;
 }
 
 // TODO: This operation is expansive. If it ever gets called multiple times we
 // may think of making a class wrapper with internal states for it.
 inline std::string getLocWithContext(const SampleContextFrameVector &Context) {
   std::ostringstream OContextStr;

llvm/tools/llvm-profgen/ProfileGenerator.cpp

for (auto Item : Boundaries) {
     }
   }
 }
 
 void ProfileGeneratorBase::updateBodySamplesforFunctionProfile(
     FunctionSamples &FunctionProfile, const SampleContextFrame &LeafLoc,
     uint64_t Count) {
   // Filter out invalid negative(int type) lineOffset
-  if (LeafLoc.Callsite.LineOffset & 0x80000000)
+  if (LeafLoc.Location.LineOffset & 0x80000000)
     return;
   // Use the maximum count of samples with same line location
   ErrorOr<uint64_t> R = FunctionProfile.findSamplesAt(
-      LeafLoc.Callsite.LineOffset, LeafLoc.Callsite.Discriminator);
+      LeafLoc.Location.LineOffset, LeafLoc.Location.Discriminator);
   uint64_t PreviousCount = R ? R.get() : 0;
   if (PreviousCount <= Count) {
-    FunctionProfile.addBodySamples(LeafLoc.Callsite.LineOffset,
-                                   LeafLoc.Callsite.Discriminator,
+    FunctionProfile.addBodySamples(LeafLoc.Location.LineOffset,
+                                   LeafLoc.Location.Discriminator,
                                    Count - PreviousCount);
   }
 }
 
 FunctionSamples &
 ProfileGenerator::getTopLevelFunctionProfile(StringRef FuncName) {
   SampleContext Context(FuncName);
   auto Ret = ProfileMap.emplace(Context, FunctionSamples());
void ProfileGenerator::generateLineNumBasedProfile() {
   // Fill in boundary sample counts as well as call site samples for calls
   populateBoundarySamplesForAllFunctions(SC.BranchCounter);
 }
 
 FunctionSamples &ProfileGenerator::getLeafProfileAndAddTotalSamples(
     const SampleContextFrameVector &FrameVec, uint64_t Count) {
   // Get top level profile
   FunctionSamples *FunctionProfile =
-      &getTopLevelFunctionProfile(FrameVec[0].CallerName);
+      &getTopLevelFunctionProfile(FrameVec[0].FuncName);
   FunctionProfile->addTotalSamples(Count);
 
   for (size_t I = 1; I < FrameVec.size(); I++) {
     FunctionSamplesMap &SamplesMap =
-        FunctionProfile->functionSamplesAt(FrameVec[I - 1].Callsite);
+        FunctionProfile->functionSamplesAt(FrameVec[I - 1].Location);
     auto Ret =
-        SamplesMap.emplace(FrameVec[I].CallerName.str(), FunctionSamples());
+        SamplesMap.emplace(FrameVec[I].FuncName.str(), FunctionSamples());
     if (Ret.second) {
-      SampleContext Context(FrameVec[I].CallerName);
+      SampleContext Context(FrameVec[I].FuncName);
       Ret.first->second.setContext(Context);
     }
     FunctionProfile = &Ret.first->second;
     FunctionProfile->addTotalSamples(Count);
   }
 
   return *FunctionProfile;
 }
if (CalleeName.size() == 0)
       continue;
     // Record called target sample and its count.
     const SampleContextFrameVector &FrameVec =
         Binary->getFrameLocationStack(SourceOffset);
     if (!FrameVec.empty()) {
       FunctionSamples &FunctionProfile =
           getLeafProfileAndAddTotalSamples(FrameVec, Count);
       FunctionProfile.addCalledTargetSamples(
-          FrameVec.back().Callsite.LineOffset,
-          FrameVec.back().Callsite.Discriminator, CalleeName, Count);
+          FrameVec.back().Location.LineOffset,
+          FrameVec.back().Location.Discriminator, CalleeName, Count);
     }
     // Add head samples for callee.
     FunctionSamples &CalleeProfile = getTopLevelFunctionProfile(CalleeName);
     CalleeProfile.addHeadSamples(Count);
   }
 }
 
 FunctionSamples &CSProfileGenerator::getFunctionProfileForContext(
StringRef CalleeName = FunctionSamples::getCanonicalFnName(
         Binary->getFuncFromStartOffset(TargetOffset));
     if (CalleeName.size() == 0)
       continue;
 
     // Record called target sample and its count
     auto LeafLoc = Binary->getInlineLeafFrameLoc(SourceOffset);
     if (!LeafLoc.hasValue())
       continue;
-    FunctionProfile.addCalledTargetSamples(LeafLoc->Callsite.LineOffset,
-                                           LeafLoc->Callsite.Discriminator,
+    FunctionProfile.addCalledTargetSamples(LeafLoc->Location.LineOffset,
+                                           LeafLoc->Location.Discriminator,
                                            CalleeName, Count);
 
     // Record head sample for called target(callee)
     SampleContextFrameVector CalleeCtx(ContextId.begin(), ContextId.end());
-    assert(CalleeCtx.back().CallerName == LeafLoc->CallerName &&
+    assert(CalleeCtx.back().FuncName == LeafLoc->FuncName &&
            "Leaf function name doesn't match");
     CalleeCtx.back() = *LeafLoc;
     CalleeCtx.emplace_back(CalleeName, LineLocation(0, 0));
     FunctionSamples &CalleeProfile = getFunctionProfileForContext(CalleeCtx);
     CalleeProfile.addHeadSamples(Count);
   }
 }
 
 static SampleContextFrame
 getCallerContext(SampleContextFrames CalleeContext,
                  SampleContextFrameVector &CallerContext) {
   assert(CalleeContext.size() > 1 && "Unexpected empty context");
   CalleeContext = CalleeContext.drop_back();
   CallerContext.assign(CalleeContext.begin(), CalleeContext.end());
   SampleContextFrame CallerFrame = CallerContext.back();
-  CallerContext.back().Callsite = LineLocation(0, 0);
+  CallerContext.back().Location = LineLocation(0, 0);
   return CallerFrame;
 }
 
 void CSProfileGenerator::populateInferredFunctionSamples() {
   for (const auto &Item : ProfileMap) {
     const auto &CalleeContext = Item.first;
     const FunctionSamples &CalleeProfile = Item.second;
 
for (const auto &Item : ProfileMap) {
 
     // Since we don't have call count for inlined functions, we
     // estimate it from inlinee's profile using entry body sample.
     uint64_t EstimatedCallCount = CalleeProfile.getEntrySamples();
     // If we don't have samples with location, use 1 to indicate live.
     if (!EstimatedCallCount && !CalleeProfile.getBodySamples().size())
       EstimatedCallCount = 1;
     CallerProfile.addCalledTargetSamples(
-        CallerLeafFrameLoc.Callsite.LineOffset,
-        CallerLeafFrameLoc.Callsite.Discriminator,
+        CallerLeafFrameLoc.Location.LineOffset,
+        CallerLeafFrameLoc.Location.Discriminator,
         CalleeProfile.getContext().getName(), EstimatedCallCount);
-    CallerProfile.addBodySamples(CallerLeafFrameLoc.Callsite.LineOffset,
-                                 CallerLeafFrameLoc.Callsite.Discriminator,
+    CallerProfile.addBodySamples(CallerLeafFrameLoc.Location.LineOffset,
+                                 CallerLeafFrameLoc.Location.Discriminator,
                                  EstimatedCallCount);
     CallerProfile.addTotalSamples(EstimatedCallCount);
   }
 }
 
 void CSProfileGenerator::postProcessProfiles() {
   // Compute hot/cold threshold based on profile. This will be used for cold
   // context profile merging/trimming.
if (Probe->isEntry()) {
         // Since the context id will be compressed, we have to use callee's
         // context id to infer caller's context id to ensure they share the
         // same context prefix.
         SampleContextFrames CalleeContextId =
             FunctionProfile.getContext().getContextFrames();
         SampleContextFrameVector CallerContextId;
         SampleContextFrame &&CallerLeafFrameLoc =
             getCallerContext(CalleeContextId, CallerContextId);
-        uint64_t CallerIndex = CallerLeafFrameLoc.Callsite.LineOffset;
+        uint64_t CallerIndex = CallerLeafFrameLoc.Location.LineOffset;
         assert(CallerIndex &&
                "Inferred caller's location index shouldn't be zero!");
         FunctionSamples &CallerProfile =
             getFunctionProfileForContext(CallerContextId);
         CallerProfile.setFunctionHash(InlinerDesc->FuncHash);
         CallerProfile.addBodySamples(CallerIndex, 0, Count);
         CallerProfile.addTotalSamples(Count);
         CallerProfile.addCalledTargetSamples(
FunctionSamples &CSProfileGenerator::getFunctionProfileForLeafProbe(
   // Explicitly copy the context for appending the leaf context
   SampleContextFrameVector NewContextStack(ContextStack.begin(),
                                            ContextStack.end());
   Binary->getInlineContextForProbe(LeafProbe, NewContextStack, true);
   // For leaf inlined context with the top frame, we should strip off the top
   // frame's probe id, like:
   // Inlined stack: [foo:1, bar:2], the ContextId will be "foo:1 @ bar"
   auto LeafFrame = NewContextStack.back();
-  LeafFrame.Callsite = LineLocation(0, 0);
+  LeafFrame.Location = LineLocation(0, 0);
   NewContextStack.pop_back();
   // Compress the context string except for the leaf frame
   CSProfileGenerator::compressRecursionContext(NewContextStack);
   CSProfileGenerator::trimContext(NewContextStack);
   NewContextStack.push_back(LeafFrame);
 
   const auto *FuncDesc = Binary->getFuncDescForGUID(LeafProbe->getGuid());
   bool WasLeafInlined = LeafProbe->getInlineTreeNode()->hasInlineSite();
   FunctionSamples &FunctionProile =
       getFunctionProfileForContext(NewContextStack, WasLeafInlined);
   FunctionProile.setFunctionHash(FuncDesc->FuncHash);
   return FunctionProile;
 }
 
 } // end namespace sampleprof
 } // end namespace llvm

llvm/tools/llvm-profgen/ProfiledBinary.cpp

static const Target *getTarget(const ObjectFile *Obj) {
   return TheTarget;
 }
 
 void BinarySizeContextTracker::addInstructionForContext(
     const SampleContextFrameVector &Context, uint32_t InstrSize) {
   ContextTrieNode *CurNode = &RootContext;
   bool IsLeaf = true;
   for (const auto &Callsite : reverse(Context)) {
-    StringRef CallerName = Callsite.CallerName;
-    LineLocation CallsiteLoc = IsLeaf ? LineLocation(0, 0) : Callsite.Callsite;
+    StringRef CallerName = Callsite.FuncName;
+    LineLocation CallsiteLoc = IsLeaf ? LineLocation(0, 0) : Callsite.Location;
     CurNode = CurNode->getOrCreateChildContext(CallsiteLoc, CallerName);
     IsLeaf = false;
   }
 
   CurNode->addFunctionSize(InstrSize);
 }
 
 uint32_t
 BinarySizeContextTracker::getFuncSizeForContext(const SampleContext &Context) {
   ContextTrieNode *CurrNode = &RootContext;
   ContextTrieNode *PrevNode = nullptr;
   SampleContextFrames Frames = Context.getContextFrames();
   int32_t I = Frames.size() - 1;
   Optional<uint32_t> Size;
 
   // Start from top-level context-less function, traverse down the reverse
   // context trie to find the best/longest match for given context, then
   // retrieve the size.
 
   while (CurrNode && I >= 0) {
     // Process from leaf function to callers (added to context).
     const auto &ChildFrame = Frames[I--];
     PrevNode = CurrNode;
     CurrNode =
-        CurrNode->getChildContext(ChildFrame.Callsite, ChildFrame.CallerName);
+        CurrNode->getChildContext(ChildFrame.Location, ChildFrame.FuncName);
     if (CurrNode && CurrNode->getFunctionSize().hasValue())
       Size = CurrNode->getFunctionSize().getValue();
   }
 
   // If we traversed all nodes along the path of the context and haven't
   // found a size yet, pivot to look for size from sibling nodes, i.e size
   // of inlinee under different context.
   if (!Size.hasValue()) {
for (auto Address : Stack) {
     WasLeafInlined = (ExpandedContext.size() > 1);
     ContextVec.append(ExpandedContext);
   }
 
   assert(ContextVec.size() && "Context length should be at least 1");
 
   // Compress the context string except for the leaf frame
   auto LeafFrame = ContextVec.back();
-  LeafFrame.Callsite = LineLocation(0, 0);
+  LeafFrame.Location = LineLocation(0, 0);
   ContextVec.pop_back();
   CSProfileGenerator::compressRecursionContext(ContextVec);
   CSProfileGenerator::trimContext(ContextVec);
   ContextVec.push_back(LeafFrame);
   return ContextVec;
 }
 
 template <class ELFT>