[llvm-profgen] Refactor PerfReader to allow different types of perf scripts

[wlei]

Summary

In order to support different types of perf scripts, this change tried to refactor PerfReader by adding the base class PerfReaderBase and current HybridPerfReader is derived from it for CS profile generation. Common functions like, passMM2PEvents, extract_lbrs, extract_callstack, etc. can be reused.

Next step is to add LBR only reader(for non-CS profile) and aggregated perf scripts reader(do a pre-aggregation of scripts).

[wlei]

fix lint

[hoy]

Thanks for working on this. We can continue from here to support more types of trace files, for non-cs profiles and more .

llvm/tools/llvm-profgen/ProfiledBinary.cpp

55

The function does more than disassembling, maybe name it LoadBinary and move it out of the ProfiledBinary class?

[wlei]

rename showBinaryDisasmOnly to loadBinaries

[hoy]

LGTM, except for a minor naming issue.

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

53

Nit: On the second thought, maybe just inlined the function here? PerfReaderBase doesn't seem a good resort for this function either since conceptually we want to by pass the perfreader and exit early.

[wenlei]

lgtm, thanks.

[wlei]

address Hongtao's feedback.

llvm/tools/llvm-profgen/PerfReader.h

 using AddressBinaryMap = std::map<uint64_t, ProfiledBinary *>;
 // Binary to ContextSampleCounters Map to support multiple binary, we may have
 // same binary loaded at different addresses, they should share the same sample
 // counter
 using BinarySampleCounterMap =
     std::unordered_map<ProfiledBinary *, ContextSampleCounterMap>;
 
 // Load binaries and read perf trace to parse the events and samples
-class PerfReader {
-
+class PerfReaderBase {
 public:
-  PerfReader(cl::list<std::string> &BinaryFilenames,
-             cl::list<std::string> &PerfTraceFilenames);
+  PerfReaderBase(cl::list<std::string> &BinaryFilenames);
+  virtual ~PerfReaderBase() = default;
+  static std::unique_ptr<PerfReaderBase>
+  create(cl::list<std::string> &BinaryFilenames,
 
   // A LBR sample is like:
   // 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) {
     if (!Line.startswith(" 0x"))
       return false;
public:
   void updateBinaryAddress(const MMapEvent &Event);
   PerfScriptType getPerfScriptType() const { return PerfType; }
   // Entry of the reader to parse multiple perf traces
   void parsePerfTraces(cl::list<std::string> &PerfTraceFilenames);
   const BinarySampleCounterMap &getBinarySampleCounters() const {
     return BinarySampleCounters;
   }
 
-private:
+protected:
   /// Validate the command line input
-  void validateCommandLine(cl::list<std::string> &BinaryFilenames,
+  static void validateCommandLine(cl::list<std::string> &BinaryFilenames,
                                   cl::list<std::string> &PerfTraceFilenames);
+  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.
   ///
   void parseMMap2Event(TraceStream &TraceIt);
   // Parse perf events/samples and do aggregation
   void parseAndAggregateTrace(StringRef Filename);
   // Parse either an MMAP event or a perf sample
   void parseEventOrSample(TraceStream &TraceIt);
-  // Parse the hybrid sample including the call and LBR line
-  void parseHybridSample(TraceStream &TraceIt);
   // Extract call stack from the perf trace lines
   bool extractCallstack(TraceStream &TraceIt,
                         SmallVectorImpl<uint64_t> &CallStack);
   // Extract LBR stack from one perf trace line
   bool extractLBRStack(TraceStream &TraceIt,
                        SmallVectorImpl<LBREntry> &LBRStack,
                        ProfiledBinary *Binary);
-  void checkAndSetPerfType(cl::list<std::string> &PerfTraceFilenames);
+  // Parse one sample from multiple perf lines, override this for different
+  // sample type
+  virtual void parseSample(TraceStream &TraceIt) = 0;
   // Post process the profile after trace aggregation, we will do simple range
   // overlap computation for AutoFDO, or unwind for CSSPGO(hybrid sample).
-  void generateRawProfile();
-  // Unwind the hybrid samples after aggregration
-  void unwindSamples();
-  void printUnwinderOutput();
+  virtual void generateRawProfile() = 0;
   // Helper function for looking up binary in AddressBinaryMap
   ProfiledBinary *getBinary(uint64_t Address);
 
   BinaryMap BinaryTable;
   AddressBinaryMap AddrToBinaryMap; // Used by address-based lookup.
 
   BinarySampleCounterMap BinarySampleCounters;
   // Samples with the repeating time generated by the perf reader
   AggregatedCounter AggregatedSamples;
   PerfScriptType PerfType = PERF_UNKNOWN;
 };
 
+/* 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 PerfReaderBase {
+public:
+  HybridPerfReader(cl::list<std::string> &BinaryFilenames)
+      : PerfReaderBase(BinaryFilenames) {
+    PerfType = PERF_LBR_STACK;
+  };
+  // Parse the hybrid sample including the call and LBR line
+  void parseSample(TraceStream &TraceIt) override;
+  void generateRawProfile() override;
+
+private:
+  // Unwind the hybrid samples after aggregration
+  void unwindSamples();
+  void printUnwinderOutput();
+};
+
 } // 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;
 }
 
-void PerfReader::validateCommandLine(
+void PerfReaderBase::validateCommandLine(
     cl::list<std::string> &BinaryFilenames,
     cl::list<std::string> &PerfTraceFilenames) {
   // 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 (CSProfileGenerator::MaxCompressionSize < -1) {
     exitWithError("Value of --compress-recursion should >= -1");
   }
   if (ShowSourceLocations && !ShowDisassemblyOnly) {
     exitWithError("--show-source-locations should work together with "
                   "--show-disassembly-only!");
   }
 }
 
-PerfReader::PerfReader(cl::list<std::string> &BinaryFilenames,
+std::unique_ptr<PerfReaderBase>
+PerfReaderBase::create(cl::list<std::string> &BinaryFilenames,
                        cl::list<std::string> &PerfTraceFilenames) {
   validateCommandLine(BinaryFilenames, PerfTraceFilenames);
+
+  PerfScriptType PerfType = extractPerfType(PerfTraceFilenames);
+  std::unique_ptr<PerfReaderBase> PerfReader;
+  if (PerfType == PERF_LBR_STACK) {
+    PerfReader.reset(new HybridPerfReader(BinaryFilenames));
+  } else if (PerfType == PERF_LBR) {
+    // TODO:
+    exitWithError("Unsupported perfscript!");
+  } else {
+    exitWithError("Unsupported perfscript!");
+  }
+
+  return PerfReader;
+}
+
+PerfReaderBase::PerfReaderBase(cl::list<std::string> &BinaryFilenames) {
   // Load the binaries.
   for (auto Filename : BinaryFilenames)
     loadBinary(Filename, /*AllowNameConflict*/ false);
 }
 
-ProfiledBinary &PerfReader::loadBinary(const StringRef BinaryPath,
+ProfiledBinary &PerfReaderBase::loadBinary(const StringRef BinaryPath,
                                            bool AllowNameConflict) {
   // The binary table is currently indexed by the binary name not the full
   // binary path. This is because the user-given path may not match the one
   // that was actually executed.
   StringRef BinaryName = llvm::sys::path::filename(BinaryPath);
 
   // Call to load the binary in the ctor of ProfiledBinary.
   auto Ret = BinaryTable.insert({BinaryName, ProfiledBinary(BinaryPath)});
 
   if (!Ret.second && !AllowNameConflict) {
     std::string ErrorMsg = "Binary name conflict: " + BinaryPath.str() +
                            " and " + Ret.first->second.getPath().str() + " \n";
     exitWithError(ErrorMsg);
   }
 
   return Ret.first->second;
 }
 
-void PerfReader::updateBinaryAddress(const MMapEvent &Event) {
+void PerfReaderBase::updateBinaryAddress(const MMapEvent &Event) {
   // Load the binary.
   StringRef BinaryPath = Event.BinaryPath;
   StringRef BinaryName = llvm::sys::path::filename(BinaryPath);
 
   auto I = BinaryTable.find(BinaryName);
   // Drop the event which doesn't belong to user-provided binaries
   // or if its image is loaded at the same address
   if (I == BinaryTable.end() || Event.Address == I->second.getBaseAddress())
if (It != Offsets.end() && *It == Event.Offset) {
         assert(*It < Event.Offset);
         if (Event.Offset - *It != Event.Address - Binary.getBaseAddress())
           exitWithError("Segment not loaded by consecutive mmaps");
       }
     }
   }
 }
 
-ProfiledBinary *PerfReader::getBinary(uint64_t Address) {
+ProfiledBinary *PerfReaderBase::getBinary(uint64_t Address) {
   auto Iter = AddrToBinaryMap.lower_bound(Address);
   if (Iter == AddrToBinaryMap.end() || Iter->first != Address) {
     if (Iter == AddrToBinaryMap.begin())
       return nullptr;
     Iter--;
   }
   return Iter->second;
 }
static void printBranchCounter(ContextSampleCounterMap &Counter,
   OrderedCounterForPrint OrderedCounter;
   for (auto &CI : Counter) {
     OrderedCounter[getContextKeyStr(CI.first.getPtr(), Binary)] =
         CI.second.BranchCounter;
   }
   printSampleCounter(OrderedCounter);
 }
 
-void PerfReader::printUnwinderOutput() {
+void HybridPerfReader::printUnwinderOutput() {
   for (auto I : BinarySampleCounters) {
     const ProfiledBinary *Binary = I.first;
     outs() << "Binary(" << Binary->getName().str() << ")'s Range Counter:\n";
     printRangeCounter(I.second, Binary);
     outs() << "\nBinary(" << Binary->getName().str() << ")'s Branch Counter:\n";
     printBranchCounter(I.second, Binary);
   }
 }
 
-void PerfReader::unwindSamples() {
+void HybridPerfReader::unwindSamples() {
   for (const auto &Item : AggregatedSamples) {
     const HybridSample *Sample = dyn_cast<HybridSample>(Item.first.getPtr());
     VirtualUnwinder Unwinder(&BinarySampleCounters[Sample->Binary],
                              Sample->Binary);
     Unwinder.unwind(Sample, Item.second);
   }
 
   if (ShowUnwinderOutput)
     printUnwinderOutput();
 }
 
-bool PerfReader::extractLBRStack(TraceStream &TraceIt,
+bool PerfReaderBase::extractLBRStack(TraceStream &TraceIt,
                                      SmallVectorImpl<LBREntry> &LBRStack,
                                      ProfiledBinary *Binary) {
   // 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.
   SmallVector<StringRef, 32> Records;
   TraceIt.getCurrentLine().split(Records, " ");
 
   // Extract leading instruction pointer if present, use single
while (Index < Records.size()) {
     // TODO: filter out buggy duplicate branches on Skylake
 
     LBRStack.emplace_back(LBREntry(Src, Dst, IsArtificial));
   }
   TraceIt.advance();
   return !LBRStack.empty();
 }
 
-bool PerfReader::extractCallstack(TraceStream &TraceIt,
+bool PerfReaderBase::extractCallstack(TraceStream &TraceIt,
                                       SmallVectorImpl<uint64_t> &CallStack) {
   // The raw format of call stack is like:
   //            4005dc      # leaf frame
   //            400634
   //            400684      # root frame
   // It's in bottom-up order with each frame in one line.
 
   // Extract stack frames from sample
   ProfiledBinary *Binary = nullptr;
bool PerfReaderBase::extractCallstack(TraceStream &TraceIt,
   // out to reduce the number of different calling contexts. One instance
   // of such case - when sample landed in prolog/epilog, somehow stack
   // walking will be broken in an unexpected way that higher frames will be
   // missing.
   return !CallStack.empty() &&
          !Binary->addressInPrologEpilog(CallStack.front());
 }
 
-void PerfReader::parseHybridSample(TraceStream &TraceIt) {
+void HybridPerfReader::parseSample(TraceStream &TraceIt) {
   // The raw hybird sample started with call stack in FILO order and followed
   // intermediately by LBR sample
   // 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
if (extractLBRStack(TraceIt, Sample->LBRStack, Sample->Binary)) {
       AggregatedSamples[Hashable<PerfSample>(Sample)]++;
     }
   } else {
     // LBR sample is encoded in single line after stack sample
     exitWithError("'Hybrid perf sample is corrupted, No LBR sample line");
   }
 }
 
-void PerfReader::parseMMap2Event(TraceStream &TraceIt) {
+void PerfReaderBase::parseMMap2Event(TraceStream &TraceIt) {
   // Parse a line like:
   //  PERF_RECORD_MMAP2 2113428/2113428: [0x7fd4efb57000(0x204000) @ 0
   //  08:04 19532229 3585508847]: r-xp /usr/lib64/libdl-2.17.so
   constexpr static const char *const Pattern =
       "PERF_RECORD_MMAP2 ([0-9]+)/[0-9]+: "
       "\\[(0x[a-f0-9]+)\\((0x[a-f0-9]+)\\) @ "
       "(0x[a-f0-9]+|0) .*\\]: [-a-z]+ (.*)";
   // Field 0 - whole line
void PerfReaderBase::parseMMap2Event(TraceStream &TraceIt) {
   updateBinaryAddress(Event);
   if (ShowMmapEvents) {
     outs() << "Mmap: Binary " << Event.BinaryPath << " loaded at "
            << format("0x%" PRIx64 ":", Event.Address) << " \n";
   }
   TraceIt.advance();
 }
 
-void PerfReader::parseEventOrSample(TraceStream &TraceIt) {
+void PerfReaderBase::parseEventOrSample(TraceStream &TraceIt) {
   if (TraceIt.getCurrentLine().startswith("PERF_RECORD_MMAP2"))
     parseMMap2Event(TraceIt);
-  else if (getPerfScriptType() == PERF_LBR_STACK)
-    parseHybridSample(TraceIt);
-  else {
-    // TODO: parse other type sample
-    TraceIt.advance();
-  }
+  else
+    parseSample(TraceIt);
 }
 
-void PerfReader::parseAndAggregateTrace(StringRef Filename) {
+void PerfReaderBase::parseAndAggregateTrace(StringRef Filename) {
   // Trace line iterator
   TraceStream TraceIt(Filename);
   while (!TraceIt.isAtEoF())
     parseEventOrSample(TraceIt);
 }
 
-void PerfReader::checkAndSetPerfType(
-    cl::list<std::string> &PerfTraceFilenames) {
+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;
   }
+  return PerfType;
 }
 
-void PerfReader::generateRawProfile() {
-  if (getPerfScriptType() == PERF_LBR_STACK) {
-    // Unwind samples if it's hybird sample
-    unwindSamples();
-  } else if (getPerfScriptType() == PERF_LBR) {
-    // TODO: range overlap computation for regular AutoFDO
-  }
-}
+void HybridPerfReader::generateRawProfile() { unwindSamples(); }
 
-void PerfReader::parsePerfTraces(cl::list<std::string> &PerfTraceFilenames) {
-  // Check and set current perfscript type
-  checkAndSetPerfType(PerfTraceFilenames);
+void PerfReaderBase::parsePerfTraces(
+    cl::list<std::string> &PerfTraceFilenames) {
   // Parse perf traces and do aggregation.
   for (auto Filename : PerfTraceFilenames)
     parseAndAggregateTrace(Filename);
 
   generateRawProfile();
 }
 
 } // end namespace sampleprof
 } // end namespace llvm

llvm/tools/llvm-profgen/ProfiledBinary.h

 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/CommandLine.h"
 #include <list>
 #include <set>
 #include <sstream>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
public:
   }
   uint64_t offsetToVirtualAddr(uint64_t Offset) const {
     return Offset + BaseAddress;
   }
   StringRef getPath() const { return Path; }
   StringRef getName() const { return llvm::sys::path::filename(Path); }
   uint64_t getBaseAddress() const { return BaseAddress; }
   void setBaseAddress(uint64_t Address) { BaseAddress = Address; }
-  
   // Return the preferred load address for the first executable segment.
   uint64_t getPreferredBaseAddress() const { return PreferredTextSegmentAddresses[0]; }
   // Return the file offset for the first executable segment.
   uint64_t getTextSegmentOffset() const { return TextSegmentOffsets[0]; }
   const std::vector<uint64_t> &getPreferredTextSegmentAddresses() const {
     return PreferredTextSegmentAddresses;
   }
   const std::vector<uint64_t> &getTextSegmentOffsets() const {
public:
 
   Optional<FrameLocation> getInlineLeafFrameLoc(uint64_t Offset) {
     const auto &Stack = getFrameLocationStack(Offset);
     if (Stack.empty())
       return {};
     return Stack.back();
   }
 
+  static void showBinaryDisasmOnly(cl::list<std::string> &BinaryFilenames);
+
   // Compare two addresses' inline context
   bool inlineContextEqual(uint64_t Add1, uint64_t Add2) const;
 
   // Get the context string of the current stack with inline context filled in.
   // It will search the disassembling info stored in Offset2LocStackMap. This is
   // used as the key of function sample map
   std::string getExpandedContextStr(const SmallVectorImpl<uint64_t> &Stack,
                                     bool &WasLeafInlined) const;

llvm/tools/llvm-profgen/ProfiledBinary.cpp

static const Target *getTarget(const ObjectFile *Obj) {
   std::string ArchName;
   const Target *TheTarget =
       TargetRegistry::lookupTarget(ArchName, TheTriple, Error);
   if (!TheTarget)
     exitWithError(Error, Obj->getFileName());
   return TheTarget;
 }
 
+void ProfiledBinary::showBinaryDisasmOnly(cl::list<std::string> &BinaryFilenames) {
+  for (auto BinaryPath : BinaryFilenames) {
+    (void)ProfiledBinary(BinaryPath);
+  }
+}
+
 void ProfiledBinary::load() {
   // Attempt to open the binary.
   OwningBinary<Binary> OBinary = unwrapOrError(createBinary(Path), Path);
   Binary &Binary = *OBinary.getBinary();
 
   auto *Obj = dyn_cast<ELFObjectFileBase>(&Binary);
   if (!Obj)
     exitWithError("not a valid Elf image", Path);

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

int main(int argc, const char *argv[]) {
   // Initialize targets and assembly printers/parsers.
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 
   cl::HideUnrelatedOptions({&ProfGenCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "llvm SPGO profile generator\n");
 
-  // Load binaries and parse perf events and samples
-  PerfReader Reader(BinaryFilenames, PerfTraceFilenames);
-  if (ShowDisassemblyOnly)
+  if (ShowDisassemblyOnly) {
+    ProfiledBinary::showBinaryDisasmOnly(BinaryFilenames);
     return EXIT_SUCCESS;
-  Reader.parsePerfTraces(PerfTraceFilenames);
+  }
+
+  // Load binaries and parse perf events and samples
+  std::unique_ptr<PerfReaderBase> Reader =
+      PerfReaderBase::create(BinaryFilenames, PerfTraceFilenames);
+  Reader->parsePerfTraces(PerfTraceFilenames);
 
   std::unique_ptr<ProfileGenerator> Generator = ProfileGenerator::create(
-      Reader.getBinarySampleCounters(), Reader.getPerfScriptType());
+      Reader->getBinarySampleCounters(), Reader->getPerfScriptType());
   Generator->generateProfile();
   Generator->write();
 
   return EXIT_SUCCESS;
 }