compilation-statistics.cc 4.99 KB
Newer Older
1 2 3 4
// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5
#include <ostream>  // NOLINT(readability/streams)
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
#include <vector>

#include "src/base/platform/platform.h"
#include "src/compilation-statistics.h"

namespace v8 {
namespace internal {

void CompilationStatistics::RecordPhaseStats(const char* phase_kind_name,
                                             const char* phase_name,
                                             const BasicStats& stats) {
  std::string phase_name_str(phase_name);
  auto it = phase_map_.find(phase_name_str);
  if (it == phase_map_.end()) {
    PhaseStats phase_stats(phase_map_.size(), phase_kind_name);
    it = phase_map_.insert(std::make_pair(phase_name_str, phase_stats)).first;
  }
  it->second.Accumulate(stats);
}


void CompilationStatistics::RecordPhaseKindStats(const char* phase_kind_name,
                                                 const BasicStats& stats) {
  std::string phase_kind_name_str(phase_kind_name);
  auto it = phase_kind_map_.find(phase_kind_name_str);
  if (it == phase_kind_map_.end()) {
    PhaseKindStats phase_kind_stats(phase_kind_map_.size());
    it = phase_kind_map_.insert(std::make_pair(phase_kind_name_str,
                                               phase_kind_stats)).first;
  }
  it->second.Accumulate(stats);
}


void CompilationStatistics::RecordTotalStats(size_t source_size,
                                             const BasicStats& stats) {
  source_size += source_size;
  total_stats_.Accumulate(stats);
}


void CompilationStatistics::BasicStats::Accumulate(const BasicStats& stats) {
  delta_ += stats.delta_;
  total_allocated_bytes_ += stats.total_allocated_bytes_;
50 51
  if (stats.absolute_max_allocated_bytes_ > absolute_max_allocated_bytes_) {
    absolute_max_allocated_bytes_ = stats.absolute_max_allocated_bytes_;
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
    max_allocated_bytes_ = stats.max_allocated_bytes_;
    function_name_ = stats.function_name_;
  }
}


static void WriteLine(std::ostream& os, const char* name,
                      const CompilationStatistics::BasicStats& stats,
                      const CompilationStatistics::BasicStats& total_stats) {
  const size_t kBufferSize = 128;
  char buffer[kBufferSize];

  double ms = stats.delta_.InMillisecondsF();
  double percent = stats.delta_.PercentOf(total_stats.delta_);
  double size_percent =
      static_cast<double>(stats.total_allocated_bytes_ * 100) /
      static_cast<double>(total_stats.total_allocated_bytes_);
  base::OS::SNPrintF(buffer, kBufferSize,
70 71 72
                     "%28s %10.3f ms / %5.1f %%"
                     "%10u total / %5.1f %% "
                     "%10u max %10u abs_max",
73
                     name, ms, percent, stats.total_allocated_bytes_,
74 75
                     size_percent, stats.max_allocated_bytes_,
                     stats.absolute_max_allocated_bytes_);
76 77 78 79 80 81 82 83 84 85

  os << buffer;
  if (stats.function_name_.size() > 0) {
    os << " : " << stats.function_name_.c_str();
  }
  os << std::endl;
}


static void WriteFullLine(std::ostream& os) {
86 87
  os << "--------------------------------------------------------"
        "--------------------------------------------------------\n";
88 89 90 91 92 93 94 95 96 97 98
}


static void WriteHeader(std::ostream& os) {
  WriteFullLine(os);
  os << "                             Turbofan timing results:\n";
  WriteFullLine(os);
}


static void WritePhaseKindBreak(std::ostream& os) {
99 100
  os << "                             ---------------------------"
        "--------------------------------------------------------\n";
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
}


std::ostream& operator<<(std::ostream& os, const CompilationStatistics& s) {
  // phase_kind_map_ and phase_map_ don't get mutated, so store a bunch of
  // pointers into them.

  typedef std::vector<CompilationStatistics::PhaseKindMap::const_iterator>
      SortedPhaseKinds;
  SortedPhaseKinds sorted_phase_kinds(s.phase_kind_map_.size());
  for (auto it = s.phase_kind_map_.begin(); it != s.phase_kind_map_.end();
       ++it) {
    sorted_phase_kinds[it->second.insert_order_] = it;
  }

  typedef std::vector<CompilationStatistics::PhaseMap::const_iterator>
      SortedPhases;
  SortedPhases sorted_phases(s.phase_map_.size());
  for (auto it = s.phase_map_.begin(); it != s.phase_map_.end(); ++it) {
    sorted_phases[it->second.insert_order_] = it;
  }

  WriteHeader(os);
  for (auto phase_kind_it : sorted_phase_kinds) {
    const auto& phase_kind_name = phase_kind_it->first;
    for (auto phase_it : sorted_phases) {
      const auto& phase_stats = phase_it->second;
      if (phase_stats.phase_kind_name_ != phase_kind_name) continue;
      const auto& phase_name = phase_it->first;
      WriteLine(os, phase_name.c_str(), phase_stats, s.total_stats_);
    }
    WritePhaseKindBreak(os);
    const auto& phase_kind_stats = phase_kind_it->second;
    WriteLine(os, phase_kind_name.c_str(), phase_kind_stats, s.total_stats_);
    os << std::endl;
  }
  WriteFullLine(os);
  WriteLine(os, "totals", s.total_stats_, s.total_stats_);

  return os;
}

}  // namespace internal
}  // namespace v8