[LNT] Added reading nm and objdump paths from env variables

[kpdev42]

Summary

• Added reading nm and objdump paths from env variables
• Added binaryCacheRoot

[thopre]

Could you split this patch up a bit?

[kpdev42]

Removed Windows support (will be done in a separate patch)

[kpdev42]

In D110839#3033772, @thopre wrote:

Could you split this patch up a bit?

Yes, please review: windows support were removed (will be done as a separate patch)

[kpdev42]

@thopre Should I rework this patch somehow?

[thopre]

In D110839#3042769, @kpdev42 wrote:

@thopre Should I rework this patch somehow?

I think ideally the bullet points in your patch description should each correspond to a different patch. That said, I don't have sufficient expertise to review everything but I might be able to review some of the resulting patches.

lnt/testing/profile/profile.py

34–36

This will set the parameters to None (and thus override the default values of the parameter) when the environment variables are not set. I don't think this is what you meant.

[slydiman]

lnt/testing/profile/profile.py

34–36

import os

def prn(x):
    print(x)

prn(x = os.getenv('MISSING_VAR', 'abc'))

Output: abc
What am I missing?

[thopre]

lnt/testing/profile/profile.py

34–36

Nothing, I missed something: the second parameter of getenv.

[yakush]

lnt/testing/profile/profile.py

34–36

this patch was actually tested in production setup, so it works at least on some platforms.

[kpdev42]

I've divided previously uploaded patch and minimized all changes. Main new functional of cPerf usage refactoring will follow in a next patch

[kpdev42]

@thopre Kindly ask you to review this version of patch

[kpdev42]

Please review this patch

[thopre]

Please add some tests for the environment variables and possibly for the bug fixes depending on what they are. This should also be split into 4 patches, one for each items mentioned. They are all independent, even if you likely made them in one go to get Linux perf work for you. One important reason for splitting is if an issue is found with one of the items the whole patch might need to be reverted. It also allow for easier cherry-pick for people who maintain their own branch of LNT.

Besides the missing tests, the patch LGTM and I'll be happy to approve it.

[slydiman]

In D110839#3074994, @thopre wrote:

Please add some tests for the environment variables and possibly for the bug fixes depending on what they are. This should also be split into 4 patches, one for each items mentioned. They are all independent, even if you likely made them in one go to get Linux perf work for you. One important reason for splitting is if an issue is found with one of the items the whole patch might need to be reverted. It also allow for easier cherry-pick for people who maintain their own branch of LNT.

Besides the missing tests, the patch LGTM and I'll be happy to approve it.

Most changes in cPerf.cpp are related to the standalone mode which is not used in the production. This mode is designed only for debug purpose. It cannot break anything.

cPerf.cpp was already designed to get nm and objdump path as the parameter (with default value).

The environment variables are used to

• redefine or specify the full path to the tools nm and objdump;
• set the root path to binaries.

What are the options? I see only 2 options - the variable is missing (current default behavior) or the variable contains a path to the tool which is used as is. What may be wrong in the code nm = os.getenv('CMAKE_NM', 'nm')?
I don't see any purpose of such tests.

It is necessary to add some executable binaries (tools) and probably some profile files to the LNT repository for requested tests. I think it is redundant and very bad idea. It is impossible to design such tests to be valid on any target or at least on most targets.

I suggest to accept this patch and commit it as is.

BTW, I see that LNT tests did not execute automatically. Something is totally broken here around LNT tests and all LNT tests are useless for now. Who should we ping to fix this?

[thopre]

In D110839#3075336, @slydiman wrote:

In D110839#3074994, @thopre wrote:

Please add some tests for the environment variables and possibly for the bug fixes depending on what they are. This should also be split into 4 patches, one for each items mentioned. They are all independent, even if you likely made them in one go to get Linux perf work for you. One important reason for splitting is if an issue is found with one of the items the whole patch might need to be reverted. It also allow for easier cherry-pick for people who maintain their own branch of LNT.

Besides the missing tests, the patch LGTM and I'll be happy to approve it.

Most changes in cPerf.cpp are related to the standalone mode which is not used in the production. This mode is designed only for debug purpose. It cannot break anything.

Still, the title does not reflect what is happening in the diff which is a clear sign the patch should be split and this is a completely independent change. If the fixes are also for standalone mode I'm happy for the patch to be split in 2 only: standalone+fixes and envvars+bincacheroot.

BTW, I see that LNT tests did not execute automatically. Something is totally broken here around LNT tests and all LNT tests are useless for now. Who should we ping to fix this?

Whoever broke the tests. There's at least 3 failures:

• plistlib change I introduced seems to only work for Python3, I'll make a patch
• future needs to be installed for mypy to work (I'm guessing some recent Python version don't have it in the standard library anymore because it used to work) I've created https://reviews.llvm.org/D112148
• Something in runtest/test_suite.shtest

I think py27 fails because of plistlib change I introduced which only works for Python 3. I need to revisit that. Python3 fails for me because I think I'm using a too new version which seems to have dropped future.

[thopre]

In D110839#3075469, @thopre wrote:

• plistlib change I introduced seems to only work for Python3, I'll make a patch

https://reviews.llvm.org/D112185

• Something in runtest/test_suite.shtest

https://reviews.llvm.org/D112182

[kpdev42]

Simplify diff

[thopre]

LGTM, thanks!

lnt/testing/profile/cPerf.cpp

 // binaries like "perf", "bash", or libaries such as libdl. We don't care about
 // these, and these binaries and libraries are very large to nm and objdump.
 //
 // So we have a threshold - if a binary contains < 1% of all samples, don't
 // bother importing it.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef STANDALONE
 #include <Python.h>
-#endif
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <exception>
 #include <fcntl.h>
 #include <iostream>
 #include <map>
 #include <sstream>
FILE *ForkAndExec(std::string Cmd) {
   
   if (fork() == 0) {
     dup2(P[1], 1);
     close(P[0]);
     execl("/bin/sh", "sh", "-c", Cmd.c_str(), 0);
   } else {
     close(P[1]);
   }
-
   return Stream;
 }
 
 void Assert(bool Expr, const char *ExprStr, const char *File, int Line) {
   if (Expr)
     return;
   char Str[512];
   sprintf(Str, "%s (%s:%d)", ExprStr, File, Line);
   throw std::logic_error(Str);
 }
 
-// Returns true if the ELF file given by filename
-// is a shared object (DYN).
-bool IsSharedObject(std::string Fname) {
-  // We replicate the first part of an ELF header here
-  // so as not to rely on <elf.h>.
-  struct PartialElfHeader {
-    unsigned char e_ident[16];
-    uint16_t e_type;
-  };
-  const int ET_DYN = 3;
-
-  FILE *stream = fopen(Fname.c_str(), "r");
-  if (stream == NULL)
-    return false;
-
-  PartialElfHeader H;
-  auto NumRead = fread(&H, 1, sizeof(H), stream);
-  assert(NumRead == sizeof(H));
-
-  fclose(stream);
-
-  return H.e_type == ET_DYN;
-}
-
 //===----------------------------------------------------------------------===//
 // Perf structures. Taken from https://lwn.net/Articles/644919/
 //===----------------------------------------------------------------------===//
 
 #define PERF_RECORD_MMAP 1
 #define PERF_RECORD_SAMPLE 9
 #define PERF_RECORD_MMAP2 10
 
struct perf_header {
   uint64_t attr_size; /* size of an attribute in attrs */
   struct perf_file_section attrs;
   struct perf_file_section data;
   struct perf_file_section event_types;
   uint64_t flags;
   uint64_t flags1[3];
 };
 
+struct perf_event_attr {
+    uint32_t type;
+    uint32_t size;
+    uint64_t config;
+    uint64_t sample_period;
+    uint64_t sample_type;
+    uint64_t read_format;
+    uint64_t flags;
+    uint32_t wakeup_events;
+    uint32_t bp_type;
+    uint64_t bp_addr;
+    uint64_t bp_len;
+    uint64_t branch_sample_type;
+};
+
 struct perf_event_header {
   uint32_t type;
   uint16_t misc;
   uint16_t size;
 };
 
 struct perf_event_sample {
   struct perf_event_header header;

 };
 
 struct perf_sample_id {
   uint32_t pid, tid;
   uint64_t time;
   uint64_t id;
 };
 
+enum perf_type_id {
+  PERF_TYPE_HARDWARE = 0,
+  PERF_TYPE_SOFTWARE = 1,
+  PERF_TYPE_TRACEPOINT = 2,
+  PERF_TYPE_HW_CACHE = 3,
+  PERF_TYPE_RAW = 4,
+  PERF_TYPE_BREAKPOINT = 5,
+  PERF_TYPE_MAX
+};
+
+enum perf_hw_id {
+  PERF_COUNT_HW_CPU_CYCLES = 0,
+  PERF_COUNT_HW_INSTRUCTIONS = 1,
+  PERF_COUNT_HW_CACHE_REFERENCES = 2,
+  PERF_COUNT_HW_CACHE_MISSES = 3,
+  PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4,
+  PERF_COUNT_HW_BRANCH_MISSES = 5,
+  PERF_COUNT_HW_BUS_CYCLES = 6,
+  PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7,
+  PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8,
+  PERF_COUNT_HW_REF_CPU_CYCLES = 9,
+  PERF_COUNT_HW_MAX
+};
+
+static const char* hw_event_names[PERF_COUNT_HW_MAX] = {
+  "cycles",
+  "instructions",
+  "cache-references",
+  "cache-misses",
+  "branch-instructions",
+  "branch-misses",
+  "bus-cycles",
+  "stalled-cycles-frontend",
+  "stalled-cycles-backend",
+  "ref-cpu-cycles"
+};
+
+enum perf_sw_ids {
+  PERF_COUNT_SW_CPU_CLOCK = 0,
+  PERF_COUNT_SW_TASK_CLOCK = 1,
+  PERF_COUNT_SW_PAGE_FAULTS = 2,
+  PERF_COUNT_SW_CONTEXT_SWITCHES = 3,
+  PERF_COUNT_SW_CPU_MIGRATIONS = 4,
+  PERF_COUNT_SW_PAGE_FAULTS_MIN = 5,
+  PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6,
+  PERF_COUNT_SW_ALIGNMENT_FAULTS = 7,
+  PERF_COUNT_SW_EMULATION_FAULTS = 8,
+  PERF_COUNT_SW_MAX
+};
+
+static const char* sw_event_names[PERF_COUNT_SW_MAX] = {
+  "cpu-clock",
+  "task-clock",
+  "page-faults",
+  "context-switches",
+  "cpu-migrations",
+  "minor-faults",
+  "major-faults",
+  "alignment-faults",
+  "emulation-faults"
+};
+
 //===----------------------------------------------------------------------===//
 // Readers for nm and objdump output
 //===----------------------------------------------------------------------===//
 
 struct Map {
-  uint64_t Start, End;
+  uint64_t Start, End, PgOff;
   const char *Filename;
 };
 
 struct Symbol {
   uint64_t Start;
   uint64_t End;
   std::string Name;
 
   bool operator<(const Symbol &Other) const { return Start < Other.Start; }
   bool operator==(const Symbol &Other) const {
     return Start == Other.Start && End == Other.End && Name == Other.Name;
   }
 };
 
 class NmOutput : public std::vector<Symbol> {
 public:
-  std::string Nm;
+  std::string BinaryCacheRoot, Nm;
 
-  NmOutput(std::string Nm) : Nm(Nm) {}
+  NmOutput(std::string BinaryCacheRoot, std::string Nm)
+    : BinaryCacheRoot(BinaryCacheRoot), Nm(Nm) {}
 
   void fetchSymbols(Map *M, bool Dynamic) {
     std::string D = "-D";
     if (!Dynamic)
       // Don't fetch the dynamic symbols - instead fetch static ones.
       D = "";
-    std::string Cmd = Nm + " " + D + " -S --defined-only " + std::string(M->Filename) +
+    std::string Cmd = Nm + " " + D + " -S --defined-only " +
+                      BinaryCacheRoot + std::string(M->Filename) +
                       " 2>/dev/null";
     auto Stream = ForkAndExec(Cmd);
 
     char *Line = nullptr;
     size_t LineLen = 0;
     while (true) {
       ssize_t Len = getline(&Line, &LineLen, Stream);
       if (Len == -1)
         break;
 
       std::vector<std::string> SplittedLine;
       if (splitLine(std::string(Line), SplittedLine) < 4)
         continue; 
 
       const std::string& One = SplittedLine[0];
       const std::string& Two = SplittedLine[1];
       const std::string& Three = SplittedLine[2];
       std::string& Four = SplittedLine[3];
 
       char *EndPtr = NULL;
-      uint64_t Start = strtoull(One.c_str(), &EndPtr, 16);
+      // Symbols with odd addresses signify functions in THUMB mode.
+      uint64_t Start = strtoull(One.c_str(), &EndPtr, 16) & ~(uint64_t)1;
       if (EndPtr == One.c_str())
         continue;
       uint64_t Extent = strtoull(Two.c_str(), &EndPtr, 16);
       if (EndPtr == Two.c_str())
         continue;
       if (Three.length() != 1)
         continue;
       switch (Three.front()) {

 
 protected:
   int splitLine(const std::string& line, std::vector<std::string>& output, char delim = ' ') {
     std::stringstream ss(line);
     std::string token;
     while (std::getline(ss, token, delim)) {
         output.push_back(token);
     }
-    return output.size();
+    return (int)output.size();
   }
 };
 
 class ObjdumpOutput {
 public:
-  std::string Objdump;
+  std::string BinaryCacheRoot, Objdump;
   FILE *Stream;
   char *ThisText;
   uint64_t ThisAddress;
   uint64_t EndAddress;
   char *Line;
   size_t LineLen;
 
-  ObjdumpOutput(std::string Objdump)
-    : Objdump(Objdump), Stream(nullptr), Line(NULL), LineLen(0) {}
+  ObjdumpOutput(std::string BinaryCacheRoot, std::string Objdump)
+    : BinaryCacheRoot(BinaryCacheRoot), Objdump(Objdump), Stream(nullptr),
+      Line(NULL), LineLen(0) {}
   ~ObjdumpOutput() {
     if (Stream) {
       fclose(Stream);
       wait(NULL);
     }
     if (Line)
       free(Line);
   }
 
   void reset(Map *M, uint64_t Start, uint64_t Stop) {
     ThisAddress = 0;
     if (Stream) {
       fclose(Stream);
       wait(NULL);
     }
 
     char buf1[32], buf2[32];
     sprintf(buf1, "%#llx", Start);
     sprintf(buf2, "%#llx", Stop + 4);
 
     std::string Cmd = Objdump + " -d --no-show-raw-insn --start-address=" +
                       std::string(buf1) + " --stop-address=" +
-                      std::string(buf2) + " " + std::string(M->Filename) +
+                      std::string(buf2) + " " +
+                      BinaryCacheRoot + std::string(M->Filename) +
                       " 2>/dev/null";
     Stream = ForkAndExec(Cmd);
 
     EndAddress = Stop;
   };
 
   std::string getText() { return ThisText; }
 

 };
 
 //===----------------------------------------------------------------------===//
 // PerfReader
 //===----------------------------------------------------------------------===//
 
 class PerfReader {
 public:
-  PerfReader(const std::string &Filename, std::string Nm,
-             std::string Objdump);
+  PerfReader(const std::string &Filename, std::string BinaryCacheRoot,
+             std::string Nm, std::string Objdump);
   ~PerfReader();
 
   void readHeader();
   void readAttrs();
+  void readEventDesc();
   void readDataStream();
   unsigned char *readEvent(unsigned char *);
   perf_event_sample parseEvent(unsigned char *Buf, uint64_t Layout);
   void emitLine(uint64_t PC, std::map<const char *, uint64_t> *Counters,
                 const std::string &Text);
   void emitFunctionStart(std::string &Name);
   void emitFunctionEnd(std::string &Name,
                        std::map<const char *, uint64_t> &Counters);
   void emitTopLevelCounters();
   void emitMaps();
   void emitSymbol(
       Symbol &Sym, Map &M,
       std::map<uint64_t, std::map<const char *, uint64_t>>::iterator Event,
-      std::map<const char *, uint64_t> &SymEvents,
-      uint64_t Adjust);
+      std::map<const char *, uint64_t> &SymEvents);
   PyObject *complete();
 
 private:
   unsigned char *Buffer;
   size_t BufferLen;
 
   perf_header *Header;
   std::map<uint64_t, const char *> EventIDs;
   std::map<uint64_t, uint64_t> EventLayouts;
   std::map<size_t, std::map<uint64_t, std::map<const char *, uint64_t>>> Events;
   std::map<const char *, uint64_t> TotalEvents;
   std::map<uint64_t, std::map<const char *, uint64_t>> TotalEventsPerMap;
   std::vector<Map> Maps;
   std::map<uint64_t, std::map<uint64_t, size_t>> CurrentMaps;
 
   PyObject *Functions, *TopLevelCounters;
   std::vector<PyObject*> Lines;
   
-  std::string Nm, Objdump;
+  std::string BinaryCacheRoot, Nm, Objdump;
 };
 
-PerfReader::PerfReader(const std::string &Filename,
+PerfReader::PerfReader(const std::string &Filename, std::string BinaryCacheRoot,
                        std::string Nm, std::string Objdump)
-    : Nm(Nm), Objdump(Objdump) {
+    : BinaryCacheRoot(BinaryCacheRoot), Nm(Nm), Objdump(Objdump) {
+  TopLevelCounters = PyDict_New();
+  Functions = PyDict_New();
   int fd = open(Filename.c_str(), O_RDONLY);
   assert(fd > 0);
 
   struct stat sb;
   assert(fstat(fd, &sb) == 0);
   BufferLen = (size_t)sb.st_size;
 
   Buffer = (unsigned char *)mmap(NULL, BufferLen, PROT_READ, MAP_SHARED, fd, 0);
   assert(Buffer != MAP_FAILED);
 }
 
-PerfReader::~PerfReader() { munmap(Buffer, BufferLen); }
+PerfReader::~PerfReader() {
+  munmap(Buffer, BufferLen);
+}
 
 void PerfReader::readHeader() {
   Header = (perf_header *)&Buffer[0];
 
   assert(!strncmp(Header->magic, "PERFILE2", 8));
 }
 
 void PerfReader::readDataStream() {
   unsigned char *Buf = &Buffer[Header->data.offset];
   unsigned char *End = Buf + Header->data.size;
   while (Buf < End)
     Buf = readEvent(Buf);
 }
 
+#define HEADER_EVENT_DESC 12
+
 void PerfReader::readAttrs() {
-  const int HEADER_EVENT_DESC = 12;
+  if (Header->flags & (1U << HEADER_EVENT_DESC)) {
+    readEventDesc();
+  } else {
+    uint64_t NumEvents = Header->attrs.size / Header->attr_size;
+    for (unsigned I = 0; I < NumEvents; ++I) {
+      const perf_event_attr* attr = (const perf_event_attr*)&Buffer[Header->attrs.offset + I * Header->attr_size];
+      const perf_file_section* ids = (const perf_file_section*)((unsigned char *)attr + attr->size);
+      unsigned char* Buf = &Buffer[ids->offset];
+      uint64_t NumIDs = ids->size / sizeof(uint64_t);
+
+      const char* Str = "unknown";
+      switch (attr->type) {
+      case PERF_TYPE_HARDWARE:
+        if (attr->config < PERF_COUNT_HW_MAX) Str = hw_event_names[attr->config];
+        break;
+      case PERF_TYPE_SOFTWARE:
+        if (attr->config < PERF_COUNT_SW_MAX) Str = sw_event_names[attr->config];
+        break;
+      }
+
+      // Weirdness of perf: if there is only one event descriptor, that
+      // event descriptor can be referred to by ANY id!
+      if (NumEvents == 1 && NumIDs == 0) {
+        EventIDs[0] = Str;
+        EventLayouts[0] = attr->sample_type;
+      }
+
+      for (unsigned J = 0; J < NumIDs; ++J) {
+        auto id = TakeU64(Buf);
+        EventIDs[id] = Str;
+        EventLayouts[id] = attr->sample_type;
+      }
+    }
+  }
+}
+
+void PerfReader::readEventDesc() {
   perf_file_section *P =
       (perf_file_section *)&Buffer[Header->data.offset + Header->data.size];
   for (int I = 0; I < HEADER_EVENT_DESC; ++I)
-    if (Header->flags & (1U << I))
+    if (Header->flags & (1ULL << I))
       ++P;
 
-  assert(Header->flags & (1U << HEADER_EVENT_DESC));
-
   unsigned char *Buf = &Buffer[P->offset];
   uint32_t NumEvents = TakeU32(Buf);
   uint32_t AttrSize = TakeU32(Buf);
   for (unsigned I = 0; I < NumEvents; ++I) {
     // Parse out the "config" bitmask for the struct layout.
     auto *Buf2 = Buf;
     (void)TakeU32(Buf2); (void)TakeU32(Buf2); (void)TakeU64(Buf2); (void)TakeU64(Buf2);
     auto Layout = TakeU64(Buf2);
for (unsigned J = 0; J < NumIDs; ++J) {
       auto L = TakeU64(Buf);
       EventIDs[L] = Str;
       EventLayouts[L] = Layout;
     }
   }
 }
 
 unsigned char *PerfReader::readEvent(unsigned char *Buf) {
-  perf_event_sample *E = (perf_event_sample *)Buf;
-  
-  if (E->header.type == PERF_RECORD_MMAP) {
+  perf_event_header *E = (perf_event_header *)Buf;
+  switch (E->type) {
+  case PERF_RECORD_MMAP:
+  {
     perf_event_mmap *E = (perf_event_mmap *)Buf;
     auto MapID = Maps.size();
-    Maps.push_back({E->start, E->start + E->extent, E->filename});
+    Maps.push_back({E->start, E->start + E->extent, E->pgoff, E->filename});
 
     // FIXME: use EventLayouts.begin()->second!
     perf_sample_id *ID =
         (perf_sample_id *)(Buf + E->header.size - sizeof(perf_sample_id));
     auto &CurrentMap = CurrentMaps[ID->time];
     CurrentMap.insert({E->start, MapID});
   }
-  if (E->header.type == PERF_RECORD_MMAP2) {
+  break;
+  case PERF_RECORD_MMAP2:
+  {
     perf_event_mmap2 *E = (perf_event_mmap2 *)Buf;
     auto MapID = Maps.size();
-    Maps.push_back({E->start, E->start + E->extent, E->filename});
+    Maps.push_back({E->start, E->start + E->extent, E->pgoff, E->filename});
 
     // FIXME: use EventLayouts.begin()->second!
     perf_sample_id *ID =
         (perf_sample_id *)(Buf + E->header.size - sizeof(perf_sample_id));
     auto &CurrentMap = CurrentMaps[ID->time];
     CurrentMap.insert({E->start, MapID});
   }
-
-  if (E->header.type != PERF_RECORD_SAMPLE)
-    return &Buf[E->header.size];
-  
+  break;
+  case PERF_RECORD_SAMPLE:
+  {
+    perf_event_sample* E = (perf_event_sample*)Buf;
     auto NewE = parseEvent(((unsigned char*)E) + sizeof(perf_event_header),
                            EventLayouts.begin()->second);
     auto EventID = NewE.id;
-  auto PC = NewE.ip;
+    auto RawPC = NewE.ip;
 
     // Search for the map corresponding to this sample. Search backwards through
     // time, discarding any maps created after our timestamp.
-  size_t MapID = ~0UL;
+    uint64_t MapID = ~0ULL;
     for (auto I = CurrentMaps.rbegin(), E = CurrentMaps.rend();
          I != E; ++I) {
       if (I->first > NewE.time)
         continue;
-    
-    auto NewI = I->second.upper_bound(PC);
+      auto NewI = I->second.upper_bound(RawPC);
       if (NewI == I->second.begin())
         continue;
       --NewI;
 
-    if (NewI->first > PC)
+      if (NewI->first > RawPC)
         continue;
       MapID = NewI->second;
       break;
     }
-  if (MapID == ~0UL)
-    return &Buf[E->header.size];
-  assert(MapID != ~0UL);
-  
+    if (MapID != ~0ULL) {
+      auto DSOPC = RawPC - Maps[MapID].Start + Maps[MapID].PgOff;
       assert(EventIDs.count(EventID));
-  Events[MapID][PC][EventIDs[EventID]] += NewE.period;
+      Events[MapID][DSOPC][EventIDs[EventID]] += NewE.period;
 
       TotalEvents[EventIDs[EventID]] += NewE.period;
       TotalEventsPerMap[MapID][EventIDs[EventID]] += NewE.period;
-
-  return &Buf[E->header.size];
+    }
+  }
+  break;
+  }
+  return &Buf[E->size];
 }
 
 perf_event_sample PerfReader::parseEvent(unsigned char *Buf, uint64_t Layout) {
   perf_event_sample E;
   memset((char*)&E, 0, sizeof(E));
 
   assert(Layout & PERF_SAMPLE_IP);
   assert(Layout & PERF_SAMPLE_PERIOD);
void PerfReader::emitLine(uint64_t PC,
   auto *Line = Py_BuildValue("[NKs]",
                              CounterDict,
                              (unsigned long long) PC,
                              (char*) Text.c_str());
   Lines.push_back(Line);
 }
 
 void PerfReader::emitTopLevelCounters() {
-  TopLevelCounters = PyDict_New();
   for (auto &KV : TotalEvents)
     PyDict_SetItemString(TopLevelCounters, KV.first,
                          PyLong_FromUnsignedLongLong((unsigned long long)KV.second));
-
-  Functions = PyDict_New();
 }
 
 void PerfReader::emitMaps() {
   for (auto &KV : Events) {
     auto MapID = KV.first;
     auto &MapEvents = KV.second;
 
     if (MapEvents.empty())
for (auto &I : TotalEventsPerMap[MapID]) {
       }
     }
     if (AllUnderThreshold)
       continue;
 
     // EXEC ELF objects aren't relocated. DYN ones are,
     // so if it's a DYN object adjust by subtracting the
     // map base.
-    bool IsSO = IsSharedObject(Maps[MapID].Filename);
-    uint64_t Adjust = IsSO ? Maps[MapID].Start : 0;
 
-    NmOutput Syms(Nm);
+    NmOutput Syms(BinaryCacheRoot, Nm);
     Syms.reset(&Maps[MapID]);
 
     // Accumulate the event totals for each symbol
     auto Sym = Syms.begin();
     auto Event = MapEvents.begin();
     std::map<uint64_t, std::map<const char*, uint64_t>> SymToEventTotals;
     while (Event != MapEvents.end() && Sym != Syms.end()) {
       // Skip events until we find one after the start of Sym
-      auto PC = Event->first - Adjust;
+      auto PC = Event->first;
       if (PC < Sym->Start) {
         ++Event;
         continue;
       }
       // Skip symbols until the event is before the end of Sym
       if (PC >= Sym->End) {
         ++Sym;
         continue;
for (auto &Sym : Syms) {
       for (auto &KV : SymToEventTotals[Sym.Start]) {
         if ((double)KV.second / (double)TotalEvents[KV.first] > 0.005) {
           Keep = true;
           break;
         }
       }
       if (Keep)
         emitSymbol(Sym, Maps[MapID], MapEvents.lower_bound(Sym.Start),
-                   SymToEventTotals[Sym.Start], Adjust);
+                   SymToEventTotals[Sym.Start]);
     }
   }
 }
 
 void PerfReader::emitSymbol(
     Symbol &Sym, Map &M,
     std::map<uint64_t, std::map<const char *, uint64_t>>::iterator Event,
-    std::map<const char *, uint64_t> &SymEvents,
-    uint64_t Adjust) {
-  ObjdumpOutput Dump(Objdump);
+    std::map<const char *, uint64_t> &SymEvents) {
+  ObjdumpOutput Dump(BinaryCacheRoot, Objdump);
   Dump.reset(&M, Sym.Start, Sym.End);
   Dump.next();
 
   emitFunctionStart(Sym.Name);
   for (uint64_t I = Sym.Start; I < Sym.End; I = Dump.next()) {
-    auto PC = Event->first - Adjust;
+    auto PC = Event->first;
 
     auto Text = Dump.getText();
     if (PC == I) {
       emitLine(I, &Event->second, Text);
       ++Event;
     } else {
       emitLine(I, nullptr, Text);
     }
   }
   emitFunctionEnd(Sym.Name, SymEvents);
 }
 
 PyObject *PerfReader::complete() {
   auto *Obj = PyDict_New();
   PyDict_SetItemString(Obj, "counters", TopLevelCounters);
   PyDict_SetItemString(Obj, "functions", Functions);
   return Obj;
 }
 
 #ifndef STANDALONE
 static PyObject *cPerf_importPerf(PyObject *self, PyObject *args) {
   const char *Fname;
+  const char *BinaryCacheRoot = "";
   const char *Nm = "nm";
   const char *Objdump = "objdump";
-  if (!PyArg_ParseTuple(args, "s|ss", &Fname, &Nm, &Objdump))
+  if (!PyArg_ParseTuple(args, "s|sss", &Fname, &BinaryCacheRoot, &Nm, &Objdump))
     return NULL;
 
   try {
-    PerfReader P(Fname, Nm, Objdump);
+    PerfReader P(Fname, BinaryCacheRoot, Nm, Objdump);
     P.readHeader();
     P.readAttrs();
     P.readDataStream();
     P.emitTopLevelCounters();
     P.emitMaps();
     return P.complete();
   } catch (std::logic_error &E) {
     PyErr_SetString(PyExc_AssertionError, E.what());

 PyMODINIT_FUNC initcPerf(void) {
   (void)Py_InitModule("cPerf", cPerfMethods);
 }
 #endif
 
 #else // STANDALONE
 
 int main(int argc, char **argv) {
-  PerfReader P(argv[1], std::cout);
+  Py_Initialize();
+  if (argc < 2)  return -1;
+  PerfReader P(argv[1], "", "nm", "objdump");
   P.readHeader();
   P.readAttrs();
   P.readDataStream();
   P.emitTopLevelCounters();
   P.emitMaps();
-  P.complete();
+  PyObject_Print(P.complete(), stdout, Py_PRINT_RAW);
+  Py_FinalizeEx();
+  return 0;
 }
 
 #endif

lnt/testing/profile/perf.py

def __init__(self):
         pass
 
     @staticmethod
     def checkFile(fn):
         with open(fn, 'rb') as f:
             return f.read(8) == b'PERFILE2'
 
     @staticmethod
-    def deserialize(f, nm='nm', objdump='objdump', propagateExceptions=False):
+    def deserialize(f, binaryCacheRoot='', nm='nm', objdump='objdump',
+                    propagateExceptions=False):
         f = f.name
 
         if os.path.getsize(f) == 0:
             # Empty file - exit early.
             return None
 
         try:
             data = cPerf.importPerf(f, nm, objdump)

lnt/testing/profile/profile.py

class Profile(object):
 
     @staticmethod
     def fromFile(f):
         """
         Load a profile from a file.
         """
         for impl in lnt.testing.profile.IMPLEMENTATIONS.values():
             if impl.checkFile(f):
-                ret = impl.deserialize(open(f, 'rb'))
+                ret = None
+                with open(f, 'rb') as fd:
+                    if impl is lnt.testing.profile.perf.LinuxPerfProfile:
+                        ret = impl.deserialize(fd,
+                                  binaryCacheRoot = os.getenv('LNT_BINARY_CACHE_ROOT', ''),
+                                  nm = os.getenv('CMAKE_NM', 'nm'),
+                                  objdump = os.getenv('CMAKE_OBJDUMP', 'objdump'))
+                    else:
+                        ret = impl.deserialize(fd)
                 if ret:
                     return Profile(ret)
                 else:
                     return None
         raise RuntimeError('No profile implementations could read this file!')
 
     @staticmethod
     def fromRendered(s):