[LNT] Updated cPerf to read the section Attributes (support Simpleperf)

[kpdev42]

Summary

The current cPerf implementation requires the feature EVENT_DESC in the profile file.
The feature EVENT_DESC is optional and is missing in profile files generated by many tools including Simpleperf.
The same data is stored in the base section Attributes. But it is necessary some heuristic around event names.

OS Laboratory, Huawei Russian Research Institute (Saint-Petersburg)

[thopre]

lnt/testing/profile/cPerf.cpp

372

Are we sure this is safe for all architectures? Is there no architecture where functions can be unaligned?

419

Why is that needed? Is it just to fix a warning?

[slydiman]

lnt/testing/profile/cPerf.cpp

419

Right. size() returns size_t.

[kpdev42]

Remove address mask

[kpdev42]

lnt/testing/profile/cPerf.cpp

372

Remove this for now (maybe will add this functionality later)

[kpdev42]

Rebase

[thopre]

lnt/testing/profile/cPerf.cpp

255–315

Is there no perf header that we could add to the tree?

721–722

Why is this no longer needed? You should adapt/remove the comment accordingly.

[kpdev42]

lnt/testing/profile/cPerf.cpp

255–315

Do you mean system headers for perf support? Unfortunately, it is not a simple task. Such headers has a lot of dependencies and cannot be easily unified to use them on all supported platforms. That is the reason why all perf-specific structures are defined in this particular file.

[thopre]

lnt/testing/profile/cPerf.cpp

255–315

Ah ok, fine to copy the data structures here then.

[kpdev42]

lnt/testing/profile/cPerf.cpp

721–722

I've added a patch for it: https://reviews.llvm.org/D113648
Please review

[thopre]

LGTM

[DavidSpickett]

This is broken on some of our bots e.g.

lnt/testing/profile/cPerf.cpp: In member function ‘unsigned char* PerfReader::readEvent(unsigned char*)’:
lnt/testing/profile/cPerf.cpp:682:14: error: expected primary-expression before ‘break’
  682 |       return break;
      |              ^~~~~

https://lab.llvm.org/buildbot/#/builders/179/builds/1765

[thopre]

lnt/testing/profile/cPerf.cpp

682

[slydiman]

lnt/testing/profile/cPerf.cpp

682

BTW, why the test build is disabled? How to enable it again?

lnt/testing/profile/cPerf.cpp

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, Adjust;
   const char *Filename;
 };
while (true) {
 
       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);
       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()) {
       default:

 
 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, BinaryCacheRoot;
   FILE *Stream;
   char *ThisText;

 class PerfReader {
 public:
   PerfReader(const std::string &Filename, std::string Nm,
              std::string Objdump, std::string BinaryCacheRoot);
   ~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 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();
     // 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(E->filename);
     Maps.push_back({E->start, E->start + E->extent,
                     IsSO ? E->start - E->pgoff : 0, 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;
     if (!(E->prot & PROT_EXEC))
-      return &Buf[E->header.size];
+      return break;
     auto MapID = Maps.size();
     // 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(E->filename);
     Maps.push_back({E->start, E->start + E->extent,
                     IsSO ? E->start - E->pgoff : 0, 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;
 
     // 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);
       if (NewI == I->second.begin())
         continue;
       --NewI;
 
       if (NewI->first > PC)
         continue;
       MapID = NewI->second;
       break;
     }
-  if (MapID == ~0UL)
-    return &Buf[E->header.size];
-  assert(MapID != ~0UL);
-  
+    if (MapID != ~0ULL) {
       assert(EventIDs.count(EventID));
       Events[MapID][PC][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);
for (auto &I : TotalEventsPerMap[MapID]) {
       // If a map contains more than 1% of some event, bother with it.
       if ((float)I.second / (float)Total > 0.01f) {
         AllUnderThreshold = false;
         break;
       }
     }
     if (AllUnderThreshold)
       continue;
 
     uint64_t Adjust = Maps[MapID].Adjust;
 
     NmOutput Syms(Nm, BinaryCacheRoot);
     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;