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
ReportContext(const Context & context)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
PrintHeader(const Run & run)55 void ConsoleReporter::PrintHeader(const Run& run) {
56 std::string str = FormatString("%-*s %13s %15s %12s", 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
ReportRuns(const std::vector<Run> & reports)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
IgnoreColorPrint(std::ostream & out,LogColor,const char * fmt,...)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
FormatTime(double time)102 static std::string FormatTime(double time) {
103 // Align decimal places...
104 if (time < 1.0) {
105 return FormatString("%10.3f", time);
106 }
107 if (time < 10.0) {
108 return FormatString("%10.2f", time);
109 }
110 if (time < 100.0) {
111 return FormatString("%10.1f", time);
112 }
113 return FormatString("%10.0f", time);
114 }
115
PrintRunData(const Run & result)116 void ConsoleReporter::PrintRunData(const Run& result) {
117 typedef void(PrinterFn)(std::ostream&, LogColor, const char*, ...);
118 auto& Out = GetOutputStream();
119 PrinterFn* printer = (output_options_ & OO_Color) ?
120 (PrinterFn*)ColorPrintf : IgnoreColorPrint;
121 auto name_color =
122 (result.report_big_o || result.report_rms) ? COLOR_BLUE : COLOR_GREEN;
123 printer(Out, name_color, "%-*s ", name_field_width_,
124 result.benchmark_name().c_str());
125
126 if (result.error_occurred) {
127 printer(Out, COLOR_RED, "ERROR OCCURRED: \'%s\'",
128 result.error_message.c_str());
129 printer(Out, COLOR_DEFAULT, "\n");
130 return;
131 }
132
133 const double real_time = result.GetAdjustedRealTime();
134 const double cpu_time = result.GetAdjustedCPUTime();
135 const std::string real_time_str = FormatTime(real_time);
136 const std::string cpu_time_str = FormatTime(cpu_time);
137
138
139 if (result.report_big_o) {
140 std::string big_o = GetBigOString(result.complexity);
141 printer(Out, COLOR_YELLOW, "%10.2f %-4s %10.2f %-4s ", real_time, big_o.c_str(),
142 cpu_time, big_o.c_str());
143 } else if (result.report_rms) {
144 printer(Out, COLOR_YELLOW, "%10.0f %-4s %10.0f %-4s ", real_time * 100, "%",
145 cpu_time * 100, "%");
146 } else {
147 const char* timeLabel = GetTimeUnitString(result.time_unit);
148 printer(Out, COLOR_YELLOW, "%s %-4s %s %-4s ", real_time_str.c_str(), timeLabel,
149 cpu_time_str.c_str(), timeLabel);
150 }
151
152 if (!result.report_big_o && !result.report_rms) {
153 printer(Out, COLOR_CYAN, "%10lld", result.iterations);
154 }
155
156 for (auto& c : result.counters) {
157 const std::size_t cNameLen = std::max(std::string::size_type(10),
158 c.first.length());
159 auto const& s = HumanReadableNumber(c.second.value, c.second.oneK);
160 if (output_options_ & OO_Tabular) {
161 if (c.second.flags & Counter::kIsRate) {
162 printer(Out, COLOR_DEFAULT, " %*s/s", cNameLen - 2, s.c_str());
163 } else {
164 printer(Out, COLOR_DEFAULT, " %*s", cNameLen, s.c_str());
165 }
166 } else {
167 const char* unit = (c.second.flags & Counter::kIsRate) ? "/s" : "";
168 printer(Out, COLOR_DEFAULT, " %s=%s%s", c.first.c_str(), s.c_str(),
169 unit);
170 }
171 }
172
173 if (!result.report_label.empty()) {
174 printer(Out, COLOR_DEFAULT, " %s", result.report_label.c_str());
175 }
176
177 printer(Out, COLOR_DEFAULT, "\n");
178 }
179
180 } // end namespace benchmark
181