[llvm-profgen] Refactor and better diagnostics

[wenlei]

Summary

This change contains diagnostics improvments, refactoring and preparation for consuming perf data directly.

Diagnostics:

• We now have more detailed diagnostics when no mmap is found.
• We also print warning for abnormal transition to external code.

Refactoring:

• Simplify input perf trace processing to only allow a single input file. This is because 1) using multiple input perf trace (perf script) is error prone because we may miss key mmap events. 2) the functionality is not really being used anyways.
• Make more functions private for Readers, move non-trivial definitions out of header. Cleanup some inconsistency.
• Prepare for consuming perf data as input directly.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.cpp

859

Remove the file name parameter because we have check perf script type in create. Providing file name here opens up the possibility of checking perf script type on one file, but parsePerfTraces on a different file. Now file name is passed in through ctor and stored as a member.

llvm/tools/llvm-profgen/llvm-profgen.cpp

51–66

We were accessing cl option ShowDisassemblyOnly and ShowSourceLocations directly, but passing BinaryPath and PerfTraceFilenames through parameters. Fix to always access cl option directly to be consistent.

[wenlei]

update

[hoy]

LGTM.

llvm/tools/llvm-profgen/PerfReader.cpp

440

Nit: "Invalid transfer" -> "Unpaired transfer"? The incoming jump may not be captured by the current trace.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.cpp

440

This is actually meant to capture cases like "internal/internal external/external" where we do see internal branches, but there's no transition. So it's different from the unpaired case below. This is implicitly guaranteed because if leaf is external, we would ignore the stack trace and throw away the entire stack+lbr. But let make add a check for Index to be explicit.

[wenlei]

update, address comment.

llvm/tools/llvm-profgen/PerfReader.h

private:
   ProfiledBinary *Binary;
   // Keep track of all untracked callsites
   std::set<uint64_t> UntrackedCallsites;
 };
 
 // Read perf trace to parse the events and samples.
 class PerfReaderBase {
 public:
-  PerfReaderBase(ProfiledBinary *B) : Binary(B) {
+  PerfReaderBase(ProfiledBinary *B, StringRef PerfTrace,
+                 PerfScriptType Type = PERF_UNKNOWN)
+      : Binary(B), PerfTraceFile(PerfTrace), PerfType(Type) {
     // Initialize the base address to preferred address.
     Binary->setBaseAddress(Binary->getPreferredBaseAddress());
   };
   virtual ~PerfReaderBase() = default;
   static std::unique_ptr<PerfReaderBase>
-  create(ProfiledBinary *Binary, cl::list<std::string> &PerfTraceFilenames);
+  create(ProfiledBinary *Binary, StringRef PerfInputFile, bool IsPerfData);
 
-  // A LBR sample is like:
-  // 40062f 0x5c6313f/0x5c63170/P/-/-/0  0x5c630e7/0x5c63130/P/-/-/0 ...
-  // A heuristic for fast detection by checking whether a
-  // leading "  0x" and the '/' exist.
-  static bool isLBRSample(StringRef Line) {
-    // Skip the leading instruction pointer
-    SmallVector<StringRef, 32> Records;
-    Line.trim().split(Records, " ", 2, false);
-    if (Records.size() < 2)
-      return false;
-    if (Records[1].startswith("0x") && Records[1].find('/') != StringRef::npos)
-      return true;
-    return false;
-  }
-
-  // The raw hybird sample is like
-  // e.g.
-  //            4005dc    # call stack leaf
-  //            400634
-  //            400684    # call stack root
-  // 0x4005c8/0x4005dc/P/-/-/0   0x40062f/0x4005b0/P/-/-/0 ...
-  //          ... 0x4005c8/0x4005dc/P/-/-/0    # LBR Entries
-  // Determine the perfscript contains hybrid samples(call stack + LBRs) by
-  // checking whether there is a non-empty call stack immediately followed by
-  // a LBR sample
-  static PerfScriptType checkPerfScriptType(StringRef FileName) {
-    TraceStream TraceIt(FileName);
-    uint64_t FrameAddr = 0;
-    while (!TraceIt.isAtEoF()) {
-      // Skip the aggregated count
-      if (!TraceIt.getCurrentLine().getAsInteger(10, FrameAddr))
-        TraceIt.advance();
-
-      // Detect sample with call stack
-      int32_t Count = 0;
-      while (!TraceIt.isAtEoF() &&
-             !TraceIt.getCurrentLine().ltrim().getAsInteger(16, FrameAddr)) {
-        Count++;
-        TraceIt.advance();
-      }
-      if (!TraceIt.isAtEoF()) {
-        if (isLBRSample(TraceIt.getCurrentLine())) {
-          if (Count > 0)
-            return PERF_LBR_STACK;
-          else
-            return PERF_LBR;
-        }
-        TraceIt.advance();
-      }
-    }
-    return PERF_INVALID;
+  PerfScriptType getPerfScriptType() const { return PerfType; }
+  // Entry of the reader to parse multiple perf traces
+  void parsePerfTraces();
+  const ContextSampleCounterMap &getSampleCounters() const {
+    return SampleCounters;
   }
+  bool profileIsCS() { return ProfileIsCS; }
 
+protected:
   // The parsed MMap event
   struct MMapEvent {
     uint64_t PID = 0;
     uint64_t Address = 0;
     uint64_t Size = 0;
     uint64_t Offset = 0;
     StringRef BinaryPath;
   };
 
+  // Check whther a given line is LBR sample
+  static bool isLBRSample(StringRef Line);
+  // Extract perf script type by peaking at the input
+  static PerfScriptType checkPerfScriptType(StringRef FileName);
+  // Update base address based on mmap events
   void updateBinaryAddress(const MMapEvent &Event);
-  // Entry of the reader to parse multiple perf traces
-  void parsePerfTraces(cl::list<std::string> &PerfTraceFilenames);
-  const ContextSampleCounterMap &getSampleCounters() const {
-    return SampleCounters;
-  }
-  bool profileIsCS() { return ProfileIsCS; }
-
-protected:
-  static PerfScriptType
-  extractPerfType(cl::list<std::string> &PerfTraceFilenames);
-  /// Parse a single line of a PERF_RECORD_MMAP2 event looking for a
-  /// mapping between the binary name and its memory layout.
-  ///
+  // Parse a single line of a PERF_RECORD_MMAP2 event looking for a
+  // mapping between the binary name and its memory layout.
   void parseMMap2Event(TraceStream &TraceIt);
   // Parse perf events/samples and do aggregation
-  void parseAndAggregateTrace(StringRef Filename);
+  void parseAndAggregateTrace();
   // Parse either an MMAP event or a perf sample
   void parseEventOrSample(TraceStream &TraceIt);
   // Warn if the relevant mmap event is missing.
   void warnIfMissingMMap();
   // Emit accumulate warnings.
   void warnTruncatedStack();
   // Extract call stack from the perf trace lines
   bool extractCallstack(TraceStream &TraceIt,
protected:
   virtual void parseSample(TraceStream &TraceIt, uint64_t Count) = 0;
   // Post process the profile after trace aggregation, we will do simple range
   // overlap computation for AutoFDO, or unwind for CSSPGO(hybrid sample).
   virtual void generateRawProfile() = 0;
   void writeRawProfile(StringRef Filename);
   void writeRawProfile(raw_fd_ostream &OS);
 
   ProfiledBinary *Binary = nullptr;
-
+  StringRef PerfTraceFile;
   ContextSampleCounterMap SampleCounters;
   // Samples with the repeating time generated by the perf reader
   AggregatedCounter AggregatedSamples;
   PerfScriptType PerfType = PERF_UNKNOWN;
   // Keep track of all invalid return addresses
   std::set<uint64_t> InvalidReturnAddresses;
 
   bool ProfileIsCS = false;
 };
 
 /*
   The reader of LBR only perf script.
   A typical LBR sample is like:
     40062f 0x4005c8/0x4005dc/P/-/-/0   0x40062f/0x4005b0/P/-/-/0 ...
           ... 0x4005c8/0x4005dc/P/-/-/0
 */
 class LBRPerfReader : public PerfReaderBase {
 public:
-  LBRPerfReader(ProfiledBinary *Binary) : PerfReaderBase(Binary) {
-    PerfType = PERF_LBR;
-  };
+  LBRPerfReader(ProfiledBinary *Binary, StringRef PerfTrace,
+                PerfScriptType Type = PERF_LBR)
+      : PerfReaderBase(Binary, PerfTrace, Type){};
   // Parse the LBR only sample.
   virtual void parseSample(TraceStream &TraceIt, uint64_t Count) override;
   virtual void generateRawProfile() override;
 
 private:
   void computeCounterFromLBR(const PerfSample *Sample, uint64_t Repeat);
 };
 
 /*
   Hybrid perf script includes a group of hybrid samples(LBRs + call stack),
   which is used to generate CS profile. An example of hybrid sample:
     4005dc    # call stack leaf
     400634
     400684    # call stack root
     0x4005c8/0x4005dc/P/-/-/0   0x40062f/0x4005b0/P/-/-/0 ...
           ... 0x4005c8/0x4005dc/P/-/-/0    # LBR Entries
 */
 class HybridPerfReader : public LBRPerfReader {
 public:
-  HybridPerfReader(ProfiledBinary *Binary) : LBRPerfReader(Binary) {
-    PerfType = PERF_LBR_STACK;
-  };
+  HybridPerfReader(ProfiledBinary *Binary, StringRef PerfTrace)
+      : LBRPerfReader(Binary, PerfTrace, PERF_LBR_STACK){};
   // Parse the hybrid sample including the call and LBR line
   void parseSample(TraceStream &TraceIt, uint64_t Count) override;
   void generateRawProfile() override;
 
 private:
   // Unwind the hybrid samples after aggregration
   void unwindSamples();
 };
 
 } // end namespace sampleprof
 } // end namespace llvm
 
 #endif

llvm/tools/llvm-profgen/PerfReader.cpp

while (State.hasNextLBR()) {
     recordBranchCount(Branch, State, Repeat);
   }
   // As samples are aggregated on trie, record them into counter map
   collectSamplesFromFrameTrie(State.getDummyRootPtr());
 
   return true;
 }
 
-std::unique_ptr<PerfReaderBase>
-PerfReaderBase::create(ProfiledBinary *Binary,
-                       cl::list<std::string> &PerfTraceFilenames) {
-  PerfScriptType PerfType = extractPerfType(PerfTraceFilenames);
+std::unique_ptr<PerfReaderBase> PerfReaderBase::create(ProfiledBinary *Binary,
+                                                       StringRef PerfInputFile,
+                                                       bool IsPerfData) {
+  // TODO: for perf data input, we need to convert them into perf script first.
+  if (IsPerfData)
+    exitWithError("Perf data input not supported yet.");
+  PerfScriptType PerfType = checkPerfScriptType(PerfInputFile);
   std::unique_ptr<PerfReaderBase> PerfReader;
   if (PerfType == PERF_LBR_STACK) {
-    PerfReader.reset(new HybridPerfReader(Binary));
+    PerfReader.reset(new HybridPerfReader(Binary, PerfInputFile));
   } else if (PerfType == PERF_LBR) {
-    PerfReader.reset(new LBRPerfReader(Binary));
+    PerfReader.reset(new LBRPerfReader(Binary, PerfInputFile));
   } else {
     exitWithError("Unsupported perfscript!");
   }
 
   return PerfReader;
 }
 
 void PerfReaderBase::updateBinaryAddress(const MMapEvent &Event) {
for (const auto &Item : AggregatedSamples) {
     AllUntrackedCallsites.insert(CurrUntrackedCallsites.begin(),
                                  CurrUntrackedCallsites.end());
   }
 
   // Warn about untracked frames due to missing probes.
   for (auto Address : AllUntrackedCallsites)
     WithColor::warning() << "Profile context truncated due to missing probe "
                          << "for call instruction at "
-                         << format("%" PRIx64, Address) << "\n";
+                         << format("0x%" PRIx64, Address) << "\n";
 }
 
 bool PerfReaderBase::extractLBRStack(TraceStream &TraceIt,
                                      SmallVectorImpl<LBREntry> &LBRStack) {
   // The raw format of LBR stack is like:
   // 0x4005c8/0x4005dc/P/-/-/0 0x40062f/0x4005b0/P/-/-/0 ...
   //                           ... 0x4005c8/0x4005dc/P/-/-/0
   // It's in FIFO order and seperated by whitespace.
while (Index < Records.size()) {
 
     bool SrcIsInternal = Binary->addressIsCode(Src);
     bool DstIsInternal = Binary->addressIsCode(Dst);
     bool IsExternal = !SrcIsInternal && !DstIsInternal;
     bool IsIncoming = !SrcIsInternal && DstIsInternal;
     bool IsOutgoing = SrcIsInternal && !DstIsInternal;
     bool IsArtificial = false;
 
-    // Ignore branches outside the current binary.
-    if (IsExternal)
+    // Ignore branches outside the current binary. Ignore all remaining branches
+    // if there's no incoming branch before the external branch in reverse
+    // order.
+    if (IsExternal) {
+      if (PrevTrDst)
         continue;
+      else if (!LBRStack.empty()) {
+        WithColor::warning()
+            << "Invalid transfer to external code in LBR record at line "
+            << TraceIt.getLineNumber() << ": " << TraceIt.getCurrentLine()
+            << "\n";
+        break;
+      }
+    }
 
     if (IsOutgoing) {
       if (!PrevTrDst) {
         // This is unpaired outgoing jump which is likely due to interrupt or
         // incomplete LBR trace. Ignore current and subsequent entries since
         // they are likely in different contexts.
         break;
       }
bool PerfReaderBase::extractCallstack(TraceStream &TraceIt,
   // walking will be broken in an unexpected way that higher frames will be
   // missing.
   return !CallStack.empty() &&
          !Binary->addressInPrologEpilog(CallStack.front());
 }
 
 void PerfReaderBase::warnIfMissingMMap() {
   if (!Binary->getMissingMMapWarned() && !Binary->getIsLoadedByMMap()) {
-    WithColor::warning() << "No relevant mmap event is matched, will use "
-                            "preferred address as the base loading address!\n";
+    WithColor::warning() << "No relevant mmap event is matched for "
+                         << Binary->getName()
+                         << ", will use preferred address ("
+                         << format("0x%" PRIx64,
+                                   Binary->getPreferredBaseAddress())
+                         << ") as the base loading address!\n";
     // Avoid redundant warning, only warn at the first unmatched sample.
     Binary->setMissingMMapWarned(true);
   }
 }
 
 void HybridPerfReader::parseSample(TraceStream &TraceIt, uint64_t Count) {
   // The raw hybird sample started with call stack in FILO order and followed
   // intermediately by LBR sample

 
 void PerfReaderBase::parseEventOrSample(TraceStream &TraceIt) {
   if (TraceIt.getCurrentLine().startswith("PERF_RECORD_MMAP2"))
     parseMMap2Event(TraceIt);
   else
     parseSample(TraceIt);
 }
 
-void PerfReaderBase::parseAndAggregateTrace(StringRef Filename) {
+void PerfReaderBase::parseAndAggregateTrace() {
   // Trace line iterator
-  TraceStream TraceIt(Filename);
+  TraceStream TraceIt(PerfTraceFile);
   while (!TraceIt.isAtEoF())
     parseEventOrSample(TraceIt);
 }
 
-PerfScriptType
-PerfReaderBase::extractPerfType(cl::list<std::string> &PerfTraceFilenames) {
-  PerfScriptType PerfType = PERF_UNKNOWN;
-  for (auto FileName : PerfTraceFilenames) {
-    PerfScriptType Type = checkPerfScriptType(FileName);
-    if (Type == PERF_INVALID)
-      exitWithError("Invalid perf script input!");
-    if (PerfType != PERF_UNKNOWN && PerfType != Type)
-      exitWithError("Inconsistent sample among different perf scripts");
-    PerfType = Type;
+// A LBR sample is like:
+// 40062f 0x5c6313f/0x5c63170/P/-/-/0  0x5c630e7/0x5c63130/P/-/-/0 ...
+// A heuristic for fast detection by checking whether a
+// leading "  0x" and the '/' exist.
+bool PerfReaderBase::isLBRSample(StringRef Line) {
+  // Skip the leading instruction pointer
+  SmallVector<StringRef, 32> Records;
+  Line.trim().split(Records, " ", 2, false);
+  if (Records.size() < 2)
+    return false;
+  if (Records[1].startswith("0x") && Records[1].find('/') != StringRef::npos)
+    return true;
+  return false;
+}
+
+// The raw hybird sample is like
+// e.g.
+//            4005dc    # call stack leaf
+//            400634
+//            400684    # call stack root
+// 0x4005c8/0x4005dc/P/-/-/0   0x40062f/0x4005b0/P/-/-/0 ...
+//          ... 0x4005c8/0x4005dc/P/-/-/0    # LBR Entries
+// Determine the perfscript contains hybrid samples(call stack + LBRs) by
+// checking whether there is a non-empty call stack immediately followed by
+// a LBR sample
+PerfScriptType PerfReaderBase::checkPerfScriptType(StringRef FileName) {
+  TraceStream TraceIt(FileName);
+  uint64_t FrameAddr = 0;
+  while (!TraceIt.isAtEoF()) {
+    // Skip the aggregated count
+    if (!TraceIt.getCurrentLine().getAsInteger(10, FrameAddr))
+      TraceIt.advance();
+
+    // Detect sample with call stack
+    int32_t Count = 0;
+    while (!TraceIt.isAtEoF() &&
+           !TraceIt.getCurrentLine().ltrim().getAsInteger(16, FrameAddr)) {
+      Count++;
+      TraceIt.advance();
     }
-  return PerfType;
+    if (!TraceIt.isAtEoF()) {
+      if (isLBRSample(TraceIt.getCurrentLine())) {
+        if (Count > 0)
+          return PERF_LBR_STACK;
+        else
+          return PERF_LBR;
+      }
+      TraceIt.advance();
+    }
+  }
+
+  exitWithError("Invalid perf script input!");
+  return PERF_INVALID;
 }
 
 void HybridPerfReader::generateRawProfile() {
   ProfileIsCS = !IgnoreStackSamples;
   if (ProfileIsCS)
     unwindSamples();
   else
     LBRPerfReader::generateRawProfile();
 }
 
 void PerfReaderBase::warnTruncatedStack() {
   for (auto Address : InvalidReturnAddresses) {
     WithColor::warning()
         << "Truncated stack sample due to invalid return address at "
         << format("0x%" PRIx64, Address)
         << ", likely caused by frame pointer omission\n";
   }
 }
 
-void PerfReaderBase::parsePerfTraces(
-    cl::list<std::string> &PerfTraceFilenames) {
+void PerfReaderBase::parsePerfTraces() {
   // Parse perf traces and do aggregation.
-  for (auto Filename : PerfTraceFilenames)
-    parseAndAggregateTrace(Filename);
+  parseAndAggregateTrace();
 
+  // Generate unsymbolized profile.
   warnTruncatedStack();
   generateRawProfile();
 
   if (SkipSymbolization)
     writeRawProfile(OutputFilename);
 }
 
 } // end namespace sampleprof
 } // end namespace llvm

llvm/tools/llvm-profgen/llvm-profgen.cpp

 #include "ProfiledBinary.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/TargetSelect.h"
 
 static cl::OptionCategory ProfGenCategory("ProfGen Options");
 
-static cl::list<std::string> PerfTraceFilenames(
-    "perfscript", cl::value_desc("perfscript"), cl::OneOrMore,
+static cl::opt<std::string> PerfTraceFilename(
+    "perfscript", cl::value_desc("perfscript"), cl::ZeroOrMore,
     llvm::cl::MiscFlags::CommaSeparated,
     cl::desc("Path of perf-script trace created by Linux perf tool with "
              "`script` command(the raw perf.data should be profiled with -b)"),
     cl::cat(ProfGenCategory));
 
+static cl::opt<std::string> PerfDataFilename(
+    "perfdata", cl::value_desc("perfdata"), cl::ZeroOrMore,
+    llvm::cl::MiscFlags::CommaSeparated,
+    cl::desc("Path of raw perf data created by Linux perf tool (it should be "
+             "profiled with -b)"),
+    cl::cat(ProfGenCategory));
+
 static cl::opt<std::string> BinaryPath(
     "binary", cl::value_desc("binary"), cl::Required,
     cl::desc("Path of profiled binary, only one binary is supported."),
     cl::cat(ProfGenCategory));
 
 extern cl::opt<bool> ShowDisassemblyOnly;
 extern cl::opt<bool> ShowSourceLocations;
 extern cl::opt<bool> SkipSymbolization;
 
 using namespace llvm;
 using namespace sampleprof;
 
 // Validate the command line input.
-static void validateCommandLine(StringRef BinaryPath,
-                                cl::list<std::string> &PerfTraceFilenames) {
+static void validateCommandLine() {
+  // Validate input profile is provided only once
+  if (PerfDataFilename.getNumOccurrences() &&
+      PerfTraceFilename.getNumOccurrences()) {
+    std::string Msg = "`-perfdata` and `-perfscript` cannot be used together.";
+    exitWithError(Msg);
+  }
+
+  // Validate input profile is provided
+  if (!PerfDataFilename.getNumOccurrences() &&
+      !PerfTraceFilename.getNumOccurrences()) {
+    std::string Msg =
+        "Use `-perfdata` or `-perfscript` to provide input perf profile.";
+    exitWithError(Msg);
+  }
+
   // Allow the invalid perfscript if we only use to show binary disassembly.
   if (!ShowDisassemblyOnly) {
-    for (auto &File : PerfTraceFilenames) {
-      if (!llvm::sys::fs::exists(File)) {
-        std::string Msg = "Input perf script(" + File + ") doesn't exist!";
-        exitWithError(Msg);
-      }
+    if (PerfTraceFilename.getNumOccurrences() &&
+        !llvm::sys::fs::exists(PerfTraceFilename)) {
+      std::string Msg =
+          "Input perf script(" + PerfTraceFilename + ") doesn't exist.";
+
+    if (PerfDataFilename.getNumOccurrences() &&
+        !llvm::sys::fs::exists(PerfDataFilename)) {
+      std::string Msg =
+          "Input perf data(" + PerfDataFilename + ") doesn't exist.";
+      exitWithError(Msg);
     }
   }
 
   if (!llvm::sys::fs::exists(BinaryPath)) {
-    std::string Msg = "Input binary(" + BinaryPath.str() + ") doesn't exist!";
+    std::string Msg = "Input binary(" + BinaryPath + ") doesn't exist.";
     exitWithError(Msg);
   }
 
   if (CSProfileGenerator::MaxCompressionSize < -1) {
     exitWithError("Value of --compress-recursion should >= -1");
   }
   if (ShowSourceLocations && !ShowDisassemblyOnly) {
     exitWithError("--show-source-locations should work together with "
                   "--show-disassembly-only!");
   }
 }
 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
   // Initialize targets and assembly printers/parsers.
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 
   cl::HideUnrelatedOptions({&ProfGenCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "llvm SPGO profile generator\n");
-  validateCommandLine(BinaryPath, PerfTraceFilenames);
+  validateCommandLine();
 
   // Load symbols and disassemble the code of a given binary.
   std::unique_ptr<ProfiledBinary> Binary =
       std::make_unique<ProfiledBinary>(BinaryPath);
   if (ShowDisassemblyOnly)
     return EXIT_SUCCESS;
 
   // Parse perf events and samples
+  StringRef PerfInputFile;
+  bool IsPerfData = PerfDataFilename.getNumOccurrences();
+  if (IsPerfData)
+    PerfInputFile = PerfDataFilename;
+  else
+    PerfInputFile = PerfTraceFilename;
   std::unique_ptr<PerfReaderBase> Reader =
-      PerfReaderBase::create(Binary.get(), PerfTraceFilenames);
-  Reader->parsePerfTraces(PerfTraceFilenames);
+      PerfReaderBase::create(Binary.get(), PerfInputFile, IsPerfData);
+  Reader->parsePerfTraces();
 
   if (SkipSymbolization)
     return EXIT_SUCCESS;
 
   std::unique_ptr<ProfileGeneratorBase> Generator =
       ProfileGeneratorBase::create(Binary.get(), Reader->getSampleCounters(),
                                    Reader->profileIsCS());
   Generator->generateProfile();
   Generator->write();
 
   return EXIT_SUCCESS;
 }