1 // Copyright 2015 Google Inc. All rights reserved. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "benchmark/benchmark.h" 16 #include "complexity.h" 17 #include "counter.h" 18 19 #include <algorithm> 20 #include <cstdint> 21 #include <cstdio> 22 #include <iostream> 23 #include <string> 24 #include <tuple> 25 #include <vector> 26 27 #include "check.h" 28 #include "colorprint.h" 29 #include "commandlineflags.h" 30 #include "internal_macros.h" 31 #include "string_util.h" 32 #include "timers.h" 33 34 namespace benchmark { 35 36 bool ConsoleReporter::ReportContext(const Context& context) { 37 name_field_width_ = context.name_field_width; 38 printed_header_ = false; 39 prev_counters_.clear(); 40 41 PrintBasicContext(&GetErrorStream(), context); 42 43 #ifdef BENCHMARK_OS_WINDOWS 44 if ((output_options_ & OO_Color) && &std::cout != &GetOutputStream()) { 45 GetErrorStream() 46 << "Color printing is only supported for stdout on windows." 47 " Disabling color printing\n"; 48 output_options_ = static_cast< OutputOptions >(output_options_ & ~OO_Color); 49 } 50 #endif 51 52 return true; 53 } 54 55 void ConsoleReporter::PrintHeader(const Run& run) { 56 std::string str = FormatString("%-*s %13s %13s %10s", static_cast<int>(name_field_width_), 57 "Benchmark", "Time", "CPU", "Iterations"); 58 if(!run.counters.empty()) { 59 if(output_options_ & OO_Tabular) { 60 for(auto const& c : run.counters) { 61 str += FormatString(" %10s", c.first.c_str()); 62 } 63 } else { 64 str += " UserCounters..."; 65 } 66 } 67 str += "\n"; 68 std::string line = std::string(str.length(), '-'); 69 GetOutputStream() << line << "\n" << str << line << "\n"; 70 } 71 72 void ConsoleReporter::ReportRuns(const std::vector<Run>& reports) { 73 for (const auto& run : reports) { 74 // print the header: 75 // --- if none was printed yet 76 bool print_header = !printed_header_; 77 // --- or if the format is tabular and this run 78 // has different fields from the prev header 79 print_header |= (output_options_ & OO_Tabular) && 80 (!internal::SameNames(run.counters, prev_counters_)); 81 if (print_header) { 82 printed_header_ = true; 83 prev_counters_ = run.counters; 84 PrintHeader(run); 85 } 86 // As an alternative to printing the headers like this, we could sort 87 // the benchmarks by header and then print. But this would require 88 // waiting for the full results before printing, or printing twice. 89 PrintRunData(run); 90 } 91 } 92 93 static void IgnoreColorPrint(std::ostream& out, LogColor, const char* fmt, 94 ...) { 95 va_list args; 96 va_start(args, fmt); 97 out << FormatString(fmt, args); 98 va_end(args); 99 } 100 101 void ConsoleReporter::PrintRunData(const Run& result) { 102 typedef void(PrinterFn)(std::ostream&, LogColor, const char*, ...); 103 auto& Out = GetOutputStream(); 104 PrinterFn* printer = (output_options_ & OO_Color) ? 105 (PrinterFn*)ColorPrintf : IgnoreColorPrint; 106 auto name_color = 107 (result.report_big_o || result.report_rms) ? COLOR_BLUE : COLOR_GREEN; 108 printer(Out, name_color, "%-*s ", name_field_width_, 109 result.benchmark_name.c_str()); 110 111 if (result.error_occurred) { 112 printer(Out, COLOR_RED, "ERROR OCCURRED: \'%s\'", 113 result.error_message.c_str()); 114 printer(Out, COLOR_DEFAULT, "\n"); 115 return; 116 } 117 // Format bytes per second 118 std::string rate; 119 if (result.bytes_per_second > 0) { 120 rate = StrCat(" ", HumanReadableNumber(result.bytes_per_second), "B/s"); 121 } 122 123 // Format items per second 124 std::string items; 125 if (result.items_per_second > 0) { 126 items = 127 StrCat(" ", HumanReadableNumber(result.items_per_second), " items/s"); 128 } 129 130 const double real_time = result.GetAdjustedRealTime(); 131 const double cpu_time = result.GetAdjustedCPUTime(); 132 133 if (result.report_big_o) { 134 std::string big_o = GetBigOString(result.complexity); 135 printer(Out, COLOR_YELLOW, "%10.2f %s %10.2f %s ", real_time, big_o.c_str(), 136 cpu_time, big_o.c_str()); 137 } else if (result.report_rms) { 138 printer(Out, COLOR_YELLOW, "%10.0f %% %10.0f %% ", real_time * 100, 139 cpu_time * 100); 140 } else { 141 const char* timeLabel = GetTimeUnitString(result.time_unit); 142 printer(Out, COLOR_YELLOW, "%10.0f %s %10.0f %s ", real_time, timeLabel, 143 cpu_time, timeLabel); 144 } 145 146 if (!result.report_big_o && !result.report_rms) { 147 printer(Out, COLOR_CYAN, "%10lld", result.iterations); 148 } 149 150 for (auto& c : result.counters) { 151 const std::size_t cNameLen = std::max(std::string::size_type(10), 152 c.first.length()); 153 auto const& s = HumanReadableNumber(c.second.value, 1000); 154 if (output_options_ & OO_Tabular) { 155 if (c.second.flags & Counter::kIsRate) { 156 printer(Out, COLOR_DEFAULT, " %*s/s", cNameLen - 2, s.c_str()); 157 } else { 158 printer(Out, COLOR_DEFAULT, " %*s", cNameLen, s.c_str()); 159 } 160 } else { 161 const char* unit = (c.second.flags & Counter::kIsRate) ? "/s" : ""; 162 printer(Out, COLOR_DEFAULT, " %s=%s%s", c.first.c_str(), s.c_str(), 163 unit); 164 } 165 } 166 167 if (!rate.empty()) { 168 printer(Out, COLOR_DEFAULT, " %*s", 13, rate.c_str()); 169 } 170 171 if (!items.empty()) { 172 printer(Out, COLOR_DEFAULT, " %*s", 18, items.c_str()); 173 } 174 175 if (!result.report_label.empty()) { 176 printer(Out, COLOR_DEFAULT, " %s", result.report_label.c_str()); 177 } 178 179 printer(Out, COLOR_DEFAULT, "\n"); 180 } 181 182 } // end namespace benchmark 183
