Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 1 | // Copyright 2014 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include <ostream> // NOLINT(readability/streams) |
| 6 | #include <vector> |
| 7 | |
| 8 | #include "src/base/platform/platform.h" |
| 9 | #include "src/compilation-statistics.h" |
| 10 | |
| 11 | namespace v8 { |
| 12 | namespace internal { |
| 13 | |
| 14 | void CompilationStatistics::RecordPhaseStats(const char* phase_kind_name, |
| 15 | const char* phase_name, |
| 16 | const BasicStats& stats) { |
| 17 | std::string phase_name_str(phase_name); |
| 18 | auto it = phase_map_.find(phase_name_str); |
| 19 | if (it == phase_map_.end()) { |
| 20 | PhaseStats phase_stats(phase_map_.size(), phase_kind_name); |
| 21 | it = phase_map_.insert(std::make_pair(phase_name_str, phase_stats)).first; |
| 22 | } |
| 23 | it->second.Accumulate(stats); |
| 24 | } |
| 25 | |
| 26 | |
| 27 | void CompilationStatistics::RecordPhaseKindStats(const char* phase_kind_name, |
| 28 | const BasicStats& stats) { |
| 29 | std::string phase_kind_name_str(phase_kind_name); |
| 30 | auto it = phase_kind_map_.find(phase_kind_name_str); |
| 31 | if (it == phase_kind_map_.end()) { |
| 32 | PhaseKindStats phase_kind_stats(phase_kind_map_.size()); |
| 33 | it = phase_kind_map_.insert(std::make_pair(phase_kind_name_str, |
| 34 | phase_kind_stats)).first; |
| 35 | } |
| 36 | it->second.Accumulate(stats); |
| 37 | } |
| 38 | |
| 39 | |
| 40 | void CompilationStatistics::RecordTotalStats(size_t source_size, |
| 41 | const BasicStats& stats) { |
| 42 | source_size += source_size; |
| 43 | total_stats_.Accumulate(stats); |
| 44 | } |
| 45 | |
| 46 | |
| 47 | void CompilationStatistics::BasicStats::Accumulate(const BasicStats& stats) { |
| 48 | delta_ += stats.delta_; |
| 49 | total_allocated_bytes_ += stats.total_allocated_bytes_; |
| 50 | if (stats.absolute_max_allocated_bytes_ > absolute_max_allocated_bytes_) { |
| 51 | absolute_max_allocated_bytes_ = stats.absolute_max_allocated_bytes_; |
| 52 | max_allocated_bytes_ = stats.max_allocated_bytes_; |
| 53 | function_name_ = stats.function_name_; |
| 54 | } |
| 55 | } |
| 56 | |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 57 | static void WriteLine(std::ostream& os, bool machine_format, const char* name, |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 58 | const CompilationStatistics::BasicStats& stats, |
| 59 | const CompilationStatistics::BasicStats& total_stats) { |
| 60 | const size_t kBufferSize = 128; |
| 61 | char buffer[kBufferSize]; |
| 62 | |
| 63 | double ms = stats.delta_.InMillisecondsF(); |
| 64 | double percent = stats.delta_.PercentOf(total_stats.delta_); |
| 65 | double size_percent = |
| 66 | static_cast<double>(stats.total_allocated_bytes_ * 100) / |
| 67 | static_cast<double>(total_stats.total_allocated_bytes_); |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 68 | if (machine_format) { |
| 69 | base::OS::SNPrintF(buffer, kBufferSize, |
| 70 | "\"%s_time\"=%.3f\n\"%s_space\"=%" PRIuS, name, ms, name, |
| 71 | stats.total_allocated_bytes_); |
| 72 | os << buffer; |
| 73 | } else { |
| 74 | base::OS::SNPrintF(buffer, kBufferSize, "%28s %10.3f (%5.1f%%) %10" PRIuS |
| 75 | " (%5.1f%%) %10" PRIuS " %10" PRIuS, |
| 76 | name, ms, percent, stats.total_allocated_bytes_, |
| 77 | size_percent, stats.max_allocated_bytes_, |
| 78 | stats.absolute_max_allocated_bytes_); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 79 | |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 80 | os << buffer; |
| 81 | if (stats.function_name_.size() > 0) { |
| 82 | os << " " << stats.function_name_.c_str(); |
| 83 | } |
| 84 | os << std::endl; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 85 | } |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | |
| 89 | static void WriteFullLine(std::ostream& os) { |
| 90 | os << "--------------------------------------------------------" |
| 91 | "--------------------------------------------------------\n"; |
| 92 | } |
| 93 | |
| 94 | |
| 95 | static void WriteHeader(std::ostream& os) { |
| 96 | WriteFullLine(os); |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 97 | os << " Turbonfan phase Time (ms) " |
| 98 | << " Space (bytes) Function\n" |
| 99 | << " " |
| 100 | << " Total Max. Abs. max.\n"; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 101 | WriteFullLine(os); |
| 102 | } |
| 103 | |
| 104 | |
| 105 | static void WritePhaseKindBreak(std::ostream& os) { |
| 106 | os << " ---------------------------" |
| 107 | "--------------------------------------------------------\n"; |
| 108 | } |
| 109 | |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 110 | std::ostream& operator<<(std::ostream& os, const AsPrintableStatistics& ps) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 111 | // phase_kind_map_ and phase_map_ don't get mutated, so store a bunch of |
| 112 | // pointers into them. |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 113 | const CompilationStatistics& s = ps.s; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 114 | |
| 115 | typedef std::vector<CompilationStatistics::PhaseKindMap::const_iterator> |
| 116 | SortedPhaseKinds; |
| 117 | SortedPhaseKinds sorted_phase_kinds(s.phase_kind_map_.size()); |
| 118 | for (auto it = s.phase_kind_map_.begin(); it != s.phase_kind_map_.end(); |
| 119 | ++it) { |
| 120 | sorted_phase_kinds[it->second.insert_order_] = it; |
| 121 | } |
| 122 | |
| 123 | typedef std::vector<CompilationStatistics::PhaseMap::const_iterator> |
| 124 | SortedPhases; |
| 125 | SortedPhases sorted_phases(s.phase_map_.size()); |
| 126 | for (auto it = s.phase_map_.begin(); it != s.phase_map_.end(); ++it) { |
| 127 | sorted_phases[it->second.insert_order_] = it; |
| 128 | } |
| 129 | |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 130 | if (!ps.machine_output) WriteHeader(os); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 131 | for (auto phase_kind_it : sorted_phase_kinds) { |
| 132 | const auto& phase_kind_name = phase_kind_it->first; |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 133 | if (!ps.machine_output) { |
| 134 | for (auto phase_it : sorted_phases) { |
| 135 | const auto& phase_stats = phase_it->second; |
| 136 | if (phase_stats.phase_kind_name_ != phase_kind_name) continue; |
| 137 | const auto& phase_name = phase_it->first; |
| 138 | WriteLine(os, ps.machine_output, phase_name.c_str(), phase_stats, |
| 139 | s.total_stats_); |
| 140 | } |
| 141 | WritePhaseKindBreak(os); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 142 | } |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 143 | const auto& phase_kind_stats = phase_kind_it->second; |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 144 | WriteLine(os, ps.machine_output, phase_kind_name.c_str(), phase_kind_stats, |
| 145 | s.total_stats_); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 146 | os << std::endl; |
| 147 | } |
Ben Murdoch | 61f157c | 2016-09-16 13:49:30 +0100 | [diff] [blame] | 148 | |
| 149 | if (!ps.machine_output) WriteFullLine(os); |
| 150 | WriteLine(os, ps.machine_output, "totals", s.total_stats_, s.total_stats_); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 151 | |
| 152 | return os; |
| 153 | } |
| 154 | |
| 155 | } // namespace internal |
| 156 | } // namespace v8 |