simpleperf/SampleDisplayer.h

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef SIMPLE_PERF_SAMPLE_DISPLAYER_H_
  18 #define SIMPLE_PERF_SAMPLE_DISPLAYER_H_
  19
  20 #include <inttypes.h>
  21
  22 #include <functional>
  23 #include <string>
  24
  25 #include <android-base/logging.h>
  26 #include <android-base/stringprintf.h>
  27
  28 // The display functions below are used to show items in a sample.
  29
  30 template <typename EntryT, typename InfoT>
  31 std::string DisplayAccumulatedOverhead(const EntryT* sample,
  32                                        const InfoT* info) {
  33   uint64_t period = sample->period + sample->accumulated_period;
  34   uint64_t total_period = info->total_period;
  35   double percentage = (total_period != 0) ? 100.0 * period / total_period : 0.0;
  36   return android::base::StringPrintf("%.2f%%", percentage);
  37 }
  38
  39 template <typename EntryT>
  40 std::string DisplayAccumulatedPeriod(const EntryT* sample) {
  41   return android::base::StringPrintf("%" PRIu64, sample->period + sample->accumulated_period);
  42 }
  43
  44 template <typename EntryT, typename InfoT>
  45 std::string DisplaySelfOverhead(const EntryT* sample, const InfoT* info) {
  46   uint64_t period = sample->period;
  47   uint64_t total_period = info->total_period;
  48   double percentage = (total_period != 0) ? 100.0 * period / total_period : 0.0;
  49   return android::base::StringPrintf("%.2f%%", percentage);
  50 }
  51
  52 #define BUILD_DISPLAY_UINT64_FUNCTION(function_name, display_part)        \
  53   template <typename EntryT>                                              \
  54   std::string function_name(const EntryT* sample) {                       \
  55     return android::base::StringPrintf("%" PRIu64, sample->display_part); \
  56   }
  57
  58 #define BUILD_DISPLAY_HEX64_FUNCTION(function_name, display_part)           \
  59   template <typename EntryT>                                                \
  60   std::string function_name(const EntryT* sample) {                         \
  61     return android::base::StringPrintf("0x%" PRIx64, sample->display_part); \
  62   }
  63
  64 BUILD_DISPLAY_UINT64_FUNCTION(DisplaySelfPeriod, period);
  65 BUILD_DISPLAY_UINT64_FUNCTION(DisplaySampleCount, sample_count);
  66
  67 template <typename EntryT>
  68 std::string DisplayPid(const EntryT* sample) {
  69   return android::base::StringPrintf("%d", sample->thread->pid);
  70 }
  71
  72 template <typename EntryT>
  73 std::string DisplayTid(const EntryT* sample) {
  74   return android::base::StringPrintf("%d", sample->thread->tid);
  75 }
  76
  77 template <typename EntryT>
  78 std::string DisplayComm(const EntryT* sample) {
  79   return sample->thread_comm;
  80 }
  81
  82 template <typename EntryT>
  83 std::string DisplayDso(const EntryT* sample) {
  84   return sample->map->dso->Path();
  85 }
  86
  87 template <typename EntryT>
  88 std::string DisplaySymbol(const EntryT* sample) {
  89   return sample->symbol->DemangledName();
  90 }
  91
  92 template <typename EntryT>
  93 std::string DisplayDsoFrom(const EntryT* sample) {
  94   return sample->branch_from.map->dso->Path();
  95 }
  96
  97 template <typename EntryT>
  98 std::string DisplaySymbolFrom(const EntryT* sample) {
  99   return sample->branch_from.symbol->DemangledName();
 100 }
 101
 102 template <typename SampleT, typename CallChainNodeT>
 103 class CallgraphDisplayer {
 104  private:
 105   static constexpr int SPACES_BETWEEN_CALLGRAPH_ENTRIES = 4;
 106
 107  public:
 108   CallgraphDisplayer(uint32_t max_stack = UINT32_MAX,
 109                      double percent_limit = 0.0,
 110                      bool brief_callgraph = false)
 111       : max_stack_(max_stack), percent_limit_(percent_limit), brief_callgraph_(brief_callgraph) {}
 112
 113   virtual ~CallgraphDisplayer() {}
 114
 115   void operator()(FILE* fp, const SampleT* sample) {
 116     if (sample->callchain.children.empty()) {
 117       return;
 118     }
 119     std::string prefix = "       ";
 120     if (brief_callgraph_ && sample->callchain.duplicated) {
 121       fprintf(fp, "%s[skipped in brief callgraph mode]\n", prefix.c_str());
 122       return;
 123     }
 124     fprintf(fp, "%s|\n", prefix.c_str());
 125     fprintf(fp, "%s-- %s\n", prefix.c_str(), PrintSampleName(sample).c_str());
 126     prefix.append(3, ' ');
 127     for (size_t i = 0; i < sample->callchain.children.size(); ++i) {
 128       DisplayCallGraphEntry(fp, 1, prefix, sample->callchain.children[i],
 129                             sample->callchain.children_period + sample->GetPeriod(),
 130                             (i + 1 == sample->callchain.children.size()));
 131     }
 132   }
 133
 134   void DisplayCallGraphEntry(FILE* fp, size_t depth, std::string prefix,
 135                              const std::unique_ptr<CallChainNodeT>& node,
 136                              uint64_t parent_period, bool last) {
 137     if (depth > max_stack_) {
 138       return;
 139     }
 140     std::string percentage_s = "-- ";
 141     if (node->period + node->children_period != parent_period) {
 142       double percentage =
 143           100.0 * (node->period + node->children_period) / parent_period;
 144       if (percentage < percent_limit_) {
 145         return;
 146       }
 147       percentage_s = android::base::StringPrintf("--%.2f%%-- ", percentage);
 148     }
 149     prefix += "|";
 150     fprintf(fp, "%s\n", prefix.c_str());
 151     if (last) {
 152       prefix.back() = ' ';
 153     }
 154     fprintf(fp, "%s%s%s\n", prefix.c_str(), percentage_s.c_str(),
 155             PrintSampleName(node->chain[0]).c_str());
 156     for (size_t i = 1; i < node->chain.size(); ++i) {
 157       fprintf(fp, "%s%*s%s\n", prefix.c_str(), static_cast<int>(percentage_s.size()), "",
 158               PrintSampleName(node->chain[i]).c_str());
 159     }
 160     prefix.append(SPACES_BETWEEN_CALLGRAPH_ENTRIES, ' ');
 161     if (!node->children.empty() && node->period != 0) {
 162       fprintf(fp, "%s|--%.2f%%-- [hit in function]\n", prefix.c_str(),
 163               100.0 * node->period / (node->period + node->children_period));
 164     }
 165     for (size_t i = 0; i < node->children.size(); ++i) {
 166       DisplayCallGraphEntry(fp, depth + 1, prefix, node->children[i],
 167                             node->children_period + node->period,
 168                             (i + 1 == node->children.size()));
 169     }
 170   }
 171
 172  protected:
 173   virtual std::string PrintSampleName(const SampleT* sample) {
 174     return sample->symbol->DemangledName();
 175   }
 176
 177  private:
 178   uint32_t max_stack_;
 179   double percent_limit_;
 180   bool brief_callgraph_;
 181 };
 182
 183 // SampleDisplayer is a class using a collections of display functions to show a
 184 // sample.
 185
 186 template <typename EntryT, typename InfoT>
 187 class SampleDisplayer {
 188  public:
 189   typedef std::string (*display_sample_func_t)(const EntryT*);
 190   typedef std::string (*display_sample_with_info_func_t)(const EntryT*,
 191                                                          const InfoT*);
 192   using exclusive_display_sample_func_t =
 193       std::function<void(FILE*, const EntryT*)>;
 194
 195  private:
 196   struct Item {
 197     std::string name;
 198     size_t width;
 199     display_sample_func_t func;
 200     display_sample_with_info_func_t func_with_info;
 201   };
 202
 203  public:
 204   void SetInfo(const InfoT* info) { info_ = info; }
 205
 206   void AddDisplayFunction(const std::string& name, display_sample_func_t func) {
 207     Item item;
 208     item.name = name;
 209     item.width = name.size();
 210     item.func = func;
 211     item.func_with_info = nullptr;
 212     display_v_.push_back(item);
 213   }
 214
 215   void AddDisplayFunction(const std::string& name,
 216                           display_sample_with_info_func_t func_with_info) {
 217     Item item;
 218     item.name = name;
 219     item.width = name.size();
 220     item.func = nullptr;
 221     item.func_with_info = func_with_info;
 222     display_v_.push_back(item);
 223   }
 224
 225   void AddExclusiveDisplayFunction(exclusive_display_sample_func_t func) {
 226     exclusive_display_v_.push_back(func);
 227   }
 228
 229   void AdjustWidth(const EntryT* sample) {
 230     for (auto& item : display_v_) {
 231       std::string data = (item.func != nullptr)
 232                              ? item.func(sample)
 233                              : item.func_with_info(sample, info_);
 234       item.width = std::max(item.width, data.size());
 235     }
 236   }
 237
 238   void PrintNames(FILE* fp) {
 239     for (size_t i = 0; i < display_v_.size(); ++i) {
 240       auto& item = display_v_[i];
 241       if (i != display_v_.size() - 1) {
 242         fprintf(fp, "%-*s  ", static_cast<int>(item.width), item.name.c_str());
 243       } else {
 244         fprintf(fp, "%s\n", item.name.c_str());
 245       }
 246     }
 247   }
 248
 249   void PrintSample(FILE* fp, const EntryT* sample) {
 250     for (size_t i = 0; i < display_v_.size(); ++i) {
 251       auto& item = display_v_[i];
 252       std::string data = (item.func != nullptr)
 253                              ? item.func(sample)
 254                              : item.func_with_info(sample, info_);
 255       if (i != display_v_.size() - 1) {
 256         fprintf(fp, "%-*s  ", static_cast<int>(item.width), data.c_str());
 257       } else {
 258         fprintf(fp, "%s\n", data.c_str());
 259       }
 260     }
 261     for (auto& func : exclusive_display_v_) {
 262       func(fp, sample);
 263     }
 264   }
 265
 266  private:
 267   const InfoT* info_;
 268   std::vector<Item> display_v_;
 269   std::vector<exclusive_display_sample_func_t> exclusive_display_v_;
 270 };
 271
 272 #endif  // SIMPLE_PERF_SAMPLE_DISPLAYER_H_