hphp/tools/tc-print/perf-events.cpp

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16 #include "hphp/tools/tc-print/perf-events.h"
  17
  18 #include <unordered_map>
  19
  20 #include "hphp/tools/tc-print/tc-print.h"
  21
  22 namespace HPHP { namespace jit {
  23
  24 using std::string;
  25
  26 // PerfEvent
  27
  28 PerfEventType perfScriptOutputToEventType(const char* eventId) {
  29
  30   // Events are duplicated so we can use the non-generic perf events.
  31   std::pair<const char*, PerfEventType> idToType[] = {
  32     std::make_pair("cycles",                    EVENT_CYCLES),
  33     std::make_pair("cpu-clock",                 EVENT_CYCLES),
  34
  35     std::make_pair("branch-misses",             EVENT_BRANCH_MISSES),
  36     std::make_pair("0x5300c5",                  EVENT_BRANCH_MISSES),
  37
  38     // fake event grouping all icache misses
  39     std::make_pair("L1-icache-misses",          EVENT_ICACHE_MISSES),
  40     // real icache miss events
  41     std::make_pair("L1-icache-load-misses",     EVENT_ICACHE_MISSES),
  42     std::make_pair("L1-icache-prefetch-misses", EVENT_ICACHE_MISSES),
  43
  44     // fake event grouping all dcache misses
  45     std::make_pair("L1-dcache-misses",          EVENT_DCACHE_MISSES),
  46     // real dcache miss events
  47     std::make_pair("L1-dcache-load-misses",     EVENT_DCACHE_MISSES),
  48     std::make_pair("L1-dcache-store-misses",    EVENT_DCACHE_MISSES),
  49     std::make_pair("L1-dcache-prefetch-misses", EVENT_DCACHE_MISSES),
  50
  51     std::make_pair("cache-misses",              EVENT_LLC_MISSES),
  52     std::make_pair("LLC-store-misses",          EVENT_LLC_STORE_MISSES),
  53
  54     // fake event grouping all iTLB misses
  55     std::make_pair("iTLB-misses",               EVENT_ITLB_MISSES),
  56     // real iTLB miss events
  57     std::make_pair("iTLB-load-misses",          EVENT_ITLB_MISSES),
  58
  59     // fake event grouping all dTLB misses
  60     std::make_pair("dTLB-misses",               EVENT_DTLB_MISSES),
  61     // real dTLB miss events
  62     std::make_pair("dTLB-load-misses",          EVENT_DTLB_MISSES),
  63     std::make_pair("dTLB-store-misses",         EVENT_DTLB_MISSES),
  64     std::make_pair("dTLB-prefetch-misses",      EVENT_DTLB_MISSES),
  65   };
  66
  67   size_t numEle = sizeof idToType / sizeof (*idToType);
  68   for (size_t i = 0; i < numEle; i++) {
  69     if (!strcmp(idToType[i].first, eventId)) return idToType[i].second;
  70   }
  71
  72   return NUM_EVENT_TYPES;
  73 }
  74
  75 const char* validArguments[] = {
  76   "cycles",
  77   "branch-misses",
  78   "L1-icache-misses",
  79   "L1-dcache-misses",
  80   "cache-misses",
  81   "LLC-store-misses",
  82   "iTLB-misses",
  83   "dTLB-misses",
  84 };
  85
  86 PerfEventType commandLineArgumentToEventType(const char* argument) {
  87   constexpr size_t numEle = sizeof validArguments / sizeof (*validArguments);
  88   static_assert(numEle == NUM_EVENT_TYPES, "need to update validArguments[]");
  89
  90   for (size_t i = 0; i < numEle; i++) {
  91     if (!strcmp(validArguments[i], argument)) return (PerfEventType)i;
  92   }
  93
  94   return NUM_EVENT_TYPES;
  95 }
  96
  97 const char* eventTypeToCommandLineArgument(PerfEventType eventType) {
  98   always_assert(eventType != NUM_EVENT_TYPES);
  99   return validArguments[eventType];
 100 }
 101
 102 // StackTraceTree
 103
 104 struct StackTraceTree::Node {
 105   typedef std::unordered_map<string, Node*> StrToPNode;
 106
 107   uint64_t inclusiveCount;
 108   uint64_t selfCount; // samples that happen precisely at this node
 109   StrToPNode children;
 110
 111   Node() : inclusiveCount(0), selfCount(0) {};
 112
 113   ~Node() {
 114     Node::StrToPNode::iterator it;
 115
 116     for (it = children.begin(); it != children.end(); it++) {
 117       delete(it->second);
 118     }
 119   }
 120
 121 private:
 122   // These are private so that we don't accidentally copy and later
 123   // double-delete one of of the pointers in children.
 124   Node(const Node& other);
 125   Node& operator=(Node other);
 126 };
 127
 128
 129 StackTraceTree::StackTraceTree() : root(new Node()) {}
 130
 131 void StackTraceTree::insert(const vector<string>& trace, uint64_t count) {
 132   if (trace.empty()) return;
 133   root.get()->inclusiveCount += count;
 134
 135   Node* curr = root.get();
 136   for (size_t i = 0; i < trace.size(); i++) {
 137     Node::StrToPNode::const_iterator it = curr->children.find(trace[i]);
 138
 139     if (it == curr->children.end()) {
 140       curr->children.insert(std::pair<string, Node*>(trace[i], new Node()));
 141     }
 142
 143     curr = curr->children[trace[i]];
 144     curr->inclusiveCount += count;
 145   }
 146
 147   curr->selfCount += count;
 148 }
 149
 150 void StackTraceTree::printTop(double minPercentage,
 151                               uint64_t eventCount) const {
 152
 153   always_assert(eventCount);
 154   uint64_t helpersCount = root.get()->inclusiveCount;
 155
 156   printf("+ samples in helpers: %" PRIu64 " (%5.2lf%%)\n",
 157          helpersCount,
 158          helpersCount * 100.0 / eventCount );
 159
 160   vector<uint32_t> activeColumns;
 161   printNode(root.get(), minPercentage, 1, activeColumns, eventCount);
 162 }
 163
 164 void printSeparators(uint32_t n, vector<uint32_t>& activeColumns) {
 165   if (!n) return;
 166   always_assert(!activeColumns.empty());
 167
 168   uint32_t cc = 0;
 169   for (uint32_t i = 1; i <= n; i++) {
 170     char c = ' ';
 171     if (cc < activeColumns.size() && activeColumns[cc] == i) {
 172       c = '|';
 173       cc++;
 174     }
 175     printf("%c  ", c);
 176   }
 177 }
 178
 179 void printGuides(uint32_t depth, vector<uint32_t>& activeColumns) {
 180   printSeparators(depth, activeColumns);
 181   printf("\n");
 182   always_assert(depth);
 183   printSeparators(depth - 1, activeColumns);
 184   printf("+--+ ");
 185 }
 186
 187 void StackTraceTree::printNode(const Node* node,
 188                                double minPercentage,
 189                                uint32_t depth,
 190                                vector<uint32_t>& activeColumns,
 191                                uint64_t eventCount) const {
 192   always_assert(eventCount);
 193   std::vector<std::pair<uint64_t, string> > activeChildren;
 194
 195   Node::StrToPNode::const_iterator it;
 196   for (it = node->children.begin(); it != node->children.end(); it++) {
 197     if (it->second->inclusiveCount * 100.0 >= minPercentage * eventCount) {
 198       activeChildren.push_back(make_pair(it->second->inclusiveCount,
 199                                          it->first));
 200     }
 201   }
 202
 203   std::sort(activeChildren.rbegin(), activeChildren.rend());
 204   if (!activeChildren.empty()) activeColumns.push_back(depth);
 205
 206   for (size_t i = 0; i < activeChildren.size(); i++) {
 207
 208     it = node->children.find(activeChildren[i].second);
 209     always_assert(it != node->children.end());
 210     const Node* next = it->second;
 211
 212     printGuides(depth, activeColumns);
 213     if (i + 1 == activeChildren.size()) activeColumns.pop_back();
 214
 215     printf("%" PRIu64 " (%.2lf%%) self: %" PRIu64 " (%.2lf%%) %s\n",
 216            next->inclusiveCount,
 217            next->inclusiveCount * 100.0 / eventCount,
 218            next->selfCount,
 219            next->selfCount * 100.0 / eventCount,
 220            activeChildren[i].second.c_str());
 221
 222     printNode(next,
 223               minPercentage,
 224               depth + 1,
 225               activeColumns,
 226               eventCount);
 227   }
 228 }
 229
 230 void StackTraceTree::aggregate(const Node* from, Node *to) {
 231   always_assert(from != nullptr && to != nullptr);
 232
 233   to->inclusiveCount += from->inclusiveCount;
 234   to->selfCount += from->selfCount;
 235
 236   Node::StrToPNode::const_iterator itFrom, itTo;
 237
 238   for (itFrom = from->children.begin();
 239        itFrom != from->children.end();
 240        itFrom++) {
 241
 242     itTo = to->children.find(itFrom->first);
 243     if (itTo == to->children.end()) {
 244       to->children.insert({itFrom->first, new Node()});
 245     }
 246
 247     aggregate(itFrom->second, to->children[itFrom->first]);
 248   }
 249 }
 250
 251 void StackTraceTree::aggregateTree(const StackTraceTree& other) {
 252   aggregate(other.root.get(), root.get());
 253 }
 254
 255 } }