[llvm-porfgen] Allow perf data as input

[wenlei]

Summary

This change enables llvm-profgen to take raw perf data as alternative input format. Sometimes we need to retrieve evenets for processes with matching binary. Using perf data as input allows us to retrieve process Ids from mmap events for matching binary, then filter by process id during perf script generation.

[wlei]

llvm/tools/llvm-profgen/PerfReader.cpp

287

Nit : command

868

Before we use "TraceIt.getCurrentLine().startswith("PERF_RECORD_MMAP2"))" for the check, why here changed to find? it seems like our regex match only supports for leading "PERF_RECORD_MMAP2"

[wenlei]

llvm/tools/llvm-profgen/PerfReader.cpp

287

fixed, thanks.

868

This is because if we want to get mmap events only, we need to use perf script --show-mmap-events -F comm,pid -i .... However with that, the mmap shows up in the following format. I have a comment above.

systemd 0 [000] 0.000000: PERF_RECORD_MMAP2 1/1: [0x7ff989ee1000(0x7d000) @ 0 00:1c 4615 6072345749617000736]: r-xp /usr/lib64/libgcrypt.so.11.8.2

The regex handles this today as it's not pinned to the beginning of the line (no ^).

[wlei]

LGTM, thanks!

llvm/tools/llvm-profgen/PerfReader.cpp

868

I see, thanks for the clarification.

[wenlei]

rebase

llvm/tools/llvm-profgen/PerfReader.h

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
+  // Generate perf script from perf data
+  static std::string convertPerfDataToTrace(ProfiledBinary *Binary,
+                                            StringRef PerfData);
+  // Check whether a given line is LBR sample
   static bool isLBRSample(StringRef Line);
+  // Check whether a given line is MMAP event
+  static bool isMMap2Event(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);
   // Parse a single line of a PERF_RECORD_MMAP2 event looking for a
   // mapping between the binary name and its memory layout.
+  static bool extractMMap2EventForBinary(ProfiledBinary *Binary, StringRef Line,
+                                         MMapEvent &MMap);
+  // Update base address based on mmap events
+  void updateBinaryAddress(const MMapEvent &Event);
+  // Parse mmap event and update binary address
   void parseMMap2Event(TraceStream &TraceIt);
   // Parse perf events/samples and do aggregation
   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.

llvm/tools/llvm-profgen/PerfReader.cpp

 //===-- PerfReader.cpp - perfscript reader  ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "PerfReader.h"
 #include "ProfileGenerator.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Process.h"
 
 #define DEBUG_TYPE "perf-reader"
 
 static cl::opt<bool> ShowMmapEvents("show-mmap-events", cl::ReallyHidden,
                                     cl::init(false), cl::ZeroOrMore,
                                     cl::desc("Print binary load events."));
 
 cl::opt<bool> SkipSymbolization("skip-symbolization", cl::ReallyHidden,
                                 cl::init(false), cl::ZeroOrMore,
                                 cl::desc("Dump the unsymbolized profile to the "
                                          "output file. It will show unwinder "
                                          "output for CS profile generation."));
 cl::opt<bool> UseOffset("use-offset", cl::ReallyHidden, cl::init(true),
                         cl::ZeroOrMore,
                         cl::desc("Work with `--skip-symbolization` to dump the "
                                  "offset instead of virtual address."));
 cl::opt<bool>
     IgnoreStackSamples("ignore-stack-samples", cl::ReallyHidden,
                        cl::init(false), cl::ZeroOrMore,
                        cl::desc("Ignore call stack samples for hybrid samples "
                                 "and produce context-insensitive profile."));
 
+extern cl::opt<std::string> PerfTraceFilename;
 extern cl::opt<bool> ShowDisassemblyOnly;
 extern cl::opt<bool> ShowSourceLocations;
 extern cl::opt<std::string> OutputFilename;
 
 namespace llvm {
 namespace sampleprof {
 
 void VirtualUnwinder::unwindCall(UnwindState &State) {
bool VirtualUnwinder::unwind(const PerfSample *Sample, uint64_t Repeat) {
   collectSamplesFromFrameTrie(State.getDummyRootPtr());
 
   return true;
 }
 
 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.");
+  // For perf data input, we need to convert them into perf script first.
+  if (IsPerfData) {
+    std::string ConvertedPerfScript =
+        convertPerfDataToTrace(Binary, PerfInputFile);
+    // Let commoand opt own the string for converted perf trace file name
+    PerfTraceFilename = ConvertedPerfScript;
+    PerfInputFile = PerfTraceFilename;
+  }
+
   PerfScriptType PerfType = checkPerfScriptType(PerfInputFile);
   std::unique_ptr<PerfReaderBase> PerfReader;
   if (PerfType == PERF_LBR_STACK) {
     PerfReader.reset(new HybridPerfReader(Binary, PerfInputFile));
   } else if (PerfType == PERF_LBR) {
     PerfReader.reset(new LBRPerfReader(Binary, PerfInputFile));
   } else {
     exitWithError("Unsupported perfscript!");
   }
 
   return PerfReader;
 }
 
+std::string PerfReaderBase::convertPerfDataToTrace(ProfiledBinary *Binary,
+                                                   StringRef PerfData) {
+  // Run perf script to retrieve PIDs matching binary we're interested in.
+  auto PerfExecutable = sys::Process::FindInEnvPath("PATH", "perf");
+  if (!PerfExecutable) {
+    exitWithError("Perf not found.");
+  }
+  std::string PerfPath = *PerfExecutable;
+  std::string PerfTraceFile = PerfData.str() + ".script.tmp";
+  StringRef ScriptMMapArgs[] = {PerfPath, "script",   "--show-mmap-events",
+                                "-F",     "comm,pid", "-i",
+                                PerfData};
+  Optional<StringRef> Redirects[] = {llvm::None,                // Stdin
+                                     StringRef(PerfTraceFile),  // Stdout
+                                     StringRef(PerfTraceFile)}; // Stderr
+  sys::ExecuteAndWait(PerfPath, ScriptMMapArgs, llvm::None, Redirects);
+
+  // Collect the PIDs
+  TraceStream TraceIt(PerfTraceFile);
+  std::string PIDs;
+  while (!TraceIt.isAtEoF()) {
+    MMapEvent MMap;
+    if (isMMap2Event(TraceIt.getCurrentLine()) &&
+        extractMMap2EventForBinary(Binary, TraceIt.getCurrentLine(), MMap)) {
+      if (!PIDs.empty()) {
+        PIDs.append(",");
+      }
+      PIDs.append(utostr(MMap.PID));
+    }
+    TraceIt.advance();
+  }
+
+  // Run perf script again to retrieve events for PIDs collected above
+  StringRef ScriptSampleArgs[] = {PerfPath, "script",     "--show-mmap-events",
+                                  "-F",     "ip,brstack", "--pid",
+                                  PIDs,     "-i",         PerfData};
+  sys::ExecuteAndWait(PerfPath, ScriptSampleArgs, llvm::None, Redirects);
+
+  return PerfTraceFile;
+}
+
 void PerfReaderBase::updateBinaryAddress(const MMapEvent &Event) {
   // Drop the event which doesn't belong to user-provided binary
   StringRef BinaryName = llvm::sys::path::filename(Event.BinaryPath);
   if (Binary->getName() != BinaryName)
     return;
 
   // Drop the event if its image is loaded at the same address
   if (Event.Address == Binary->getBaseAddress()) {
while (!TraceIt.isAtEoF() && !TraceIt.getCurrentLine().startswith(" 0x")) {
     if (FrameStr.getAsInteger(16, FrameAddr)) {
       // We might parse a non-perf sample line like empty line and comments,
       // skip it
       TraceIt.advance();
       return false;
     }
     TraceIt.advance();
     // Currently intermixed frame from different binaries is not supported.
-    // Ignore bottom frames not from binary of interest.
+    // Ignore caller frames not from binary of interest.
     if (!Binary->addressIsCode(FrameAddr))
       break;
 
     // We need to translate return address to call address for non-leaf frames.
     if (!CallStack.empty()) {
       auto CallAddr = Binary->getCallAddrFromFrameAddr(FrameAddr);
       if (!CallAddr) {
         // Stop at an invalid return address caused by bad unwinding. This could

 }
 
 void PerfReaderBase::parseSample(TraceStream &TraceIt) {
   uint64_t Count = parseAggregatedCount(TraceIt);
   assert(Count >= 1 && "Aggregated count should be >= 1!");
   parseSample(TraceIt, Count);
 }
 
-void PerfReaderBase::parseMMap2Event(TraceStream &TraceIt) {
+bool PerfReaderBase::extractMMap2EventForBinary(ProfiledBinary *Binary,
+                                                StringRef Line,
+                                                MMapEvent &MMap) {
   // 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
   // Field 1 - PID
   // Field 2 - base address
   // Field 3 - mmapped size
   // Field 4 - page offset
   // Field 5 - binary path
   enum EventIndex {
     WHOLE_LINE = 0,
     PID = 1,
     MMAPPED_ADDRESS = 2,
     MMAPPED_SIZE = 3,
     PAGE_OFFSET = 4,
     BINARY_PATH = 5
   };
 
   Regex RegMmap2(Pattern);
   SmallVector<StringRef, 6> Fields;
-  bool R = RegMmap2.match(TraceIt.getCurrentLine(), &Fields);
+  bool R = RegMmap2.match(Line, &Fields);
   if (!R) {
-    std::string ErrorMsg = "Cannot parse mmap event: Line" +
-                           Twine(TraceIt.getLineNumber()).str() + ": " +
-                           TraceIt.getCurrentLine().str() + " \n";
+    std::string ErrorMsg = "Cannot parse mmap event: " + Line.str() + " \n";
     exitWithError(ErrorMsg);
   }
-  MMapEvent Event;
-  Fields[PID].getAsInteger(10, Event.PID);
-  Fields[MMAPPED_ADDRESS].getAsInteger(0, Event.Address);
-  Fields[MMAPPED_SIZE].getAsInteger(0, Event.Size);
-  Fields[PAGE_OFFSET].getAsInteger(0, Event.Offset);
-  Event.BinaryPath = Fields[BINARY_PATH];
-  updateBinaryAddress(Event);
+  Fields[PID].getAsInteger(10, MMap.PID);
+  Fields[MMAPPED_ADDRESS].getAsInteger(0, MMap.Address);
+  Fields[MMAPPED_SIZE].getAsInteger(0, MMap.Size);
+  Fields[PAGE_OFFSET].getAsInteger(0, MMap.Offset);
+  MMap.BinaryPath = Fields[BINARY_PATH];
   if (ShowMmapEvents) {
-    outs() << "Mmap: Binary " << Event.BinaryPath << " loaded at "
-           << format("0x%" PRIx64 ":", Event.Address) << " \n";
-  }
+    outs() << "Mmap: Binary " << MMap.BinaryPath << " loaded at "
+           << format("0x%" PRIx64 ":", MMap.Address) << " \n";
+  }
+
+  StringRef BinaryName = llvm::sys::path::filename(MMap.BinaryPath);
+  return Binary->getName() == BinaryName;
+
+void PerfReaderBase::parseMMap2Event(TraceStream &TraceIt) {
+  MMapEvent MMap;
+  if (extractMMap2EventForBinary(Binary, TraceIt.getCurrentLine(), MMap))
+    updateBinaryAddress(MMap);
   TraceIt.advance();
 }
 
 void PerfReaderBase::parseEventOrSample(TraceStream &TraceIt) {
-  if (TraceIt.getCurrentLine().startswith("PERF_RECORD_MMAP2"))
+  if (isMMap2Event(TraceIt.getCurrentLine()))
     parseMMap2Event(TraceIt);
   else
     parseSample(TraceIt);
 }
 
 void PerfReaderBase::parseAndAggregateTrace() {
   // Trace line iterator
   TraceStream TraceIt(PerfTraceFile);
bool PerfReaderBase::isLBRSample(StringRef Line) {
   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;
 }
 
+bool PerfReaderBase::isMMap2Event(StringRef Line) {
+  // Short cut to avoid string find is possible.
+  if (Line.empty() || Line.size() < 50)
+    return false;
+
+  if (std::isdigit(Line[0]))
+    return false;
+
+  // PERF_RECORD_MMAP2 does not appear at the beginning of the line
+  // for ` perf script  --show-mmap-events  -i ...`
+  return Line.find("PERF_RECORD_MMAP2") != StringRef::npos;
+}
+
 // 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

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::opt<std::string> PerfTraceFilename(
+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,