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 <algorithm>
16#include <cstdint>
17#include <cstdio>
18#include <cstring>
19#include <iostream>
20#include <string>
21#include <tuple>
22#include <vector>
23
24#include "benchmark/benchmark.h"
25#include "check.h"
26#include "colorprint.h"
27#include "commandlineflags.h"
28#include "complexity.h"
29#include "counter.h"
30#include "internal_macros.h"
31#include "string_util.h"
32#include "timers.h"
33
34namespace benchmark {
35
36BENCHMARK_EXPORT
37bool ConsoleReporter::ReportContext(const Context& context) {
38 name_field_width_ = context.name_field_width;
39 printed_header_ = false;
40 prev_counters_.clear();
41
42 PrintBasicContext(out: &GetErrorStream(), context);
43
44#ifdef BENCHMARK_OS_WINDOWS
45 if ((output_options_ & OO_Color)) {
46 auto stdOutBuf = std::cout.rdbuf();
47 auto outStreamBuf = GetOutputStream().rdbuf();
48 if (stdOutBuf != outStreamBuf) {
49 GetErrorStream()
50 << "Color printing is only supported for stdout on windows."
51 " Disabling color printing\n";
52 output_options_ = static_cast<OutputOptions>(output_options_ & ~OO_Color);
53 }
54 }
55#endif
56
57 return true;
58}
59
60BENCHMARK_EXPORT
61void ConsoleReporter::PrintHeader(const Run& run) {
62 std::string str =
63 FormatString(msg: "%-*s %13s %15s %12s", static_cast<int>(name_field_width_),
64 "Benchmark", "Time", "CPU", "Iterations");
65 if (!run.counters.empty()) {
66 if (output_options_ & OO_Tabular) {
67 for (auto const& c : run.counters) {
68 str += FormatString(msg: " %10s", c.first.c_str());
69 }
70 } else {
71 str += " UserCounters...";
72 }
73 }
74 std::string line = std::string(str.length(), '-');
75 GetOutputStream() << line << "\n" << str << "\n" << line << "\n";
76}
77
78BENCHMARK_EXPORT
79void ConsoleReporter::ReportRuns(const std::vector<Run>& reports) {
80 for (const auto& run : reports) {
81 // print the header:
82 // --- if none was printed yet
83 bool print_header = !printed_header_;
84 // --- or if the format is tabular and this run
85 // has different fields from the prev header
86 print_header |= (output_options_ & OO_Tabular) &&
87 (!internal::SameNames(l: run.counters, r: prev_counters_));
88 if (print_header) {
89 printed_header_ = true;
90 prev_counters_ = run.counters;
91 PrintHeader(run);
92 }
93 // As an alternative to printing the headers like this, we could sort
94 // the benchmarks by header and then print. But this would require
95 // waiting for the full results before printing, or printing twice.
96 PrintRunData(report: run);
97 }
98}
99
100static void IgnoreColorPrint(std::ostream& out, LogColor, const char* fmt,
101 ...) {
102 va_list args;
103 va_start(args, fmt);
104 out << FormatString(msg: fmt, args);
105 va_end(args);
106}
107
108static std::string FormatTime(double time) {
109 // For the time columns of the console printer 13 digits are reserved. One of
110 // them is a space and max two of them are the time unit (e.g ns). That puts
111 // us at 10 digits usable for the number.
112 // Align decimal places...
113 if (time < 1.0) {
114 return FormatString(msg: "%10.3f", time);
115 }
116 if (time < 10.0) {
117 return FormatString(msg: "%10.2f", time);
118 }
119 if (time < 100.0) {
120 return FormatString(msg: "%10.1f", time);
121 }
122 // Assuming the time is at max 9.9999e+99 and we have 10 digits for the
123 // number, we get 10-1(.)-1(e)-1(sign)-2(exponent) = 5 digits to print.
124 if (time > 9999999999 /*max 10 digit number*/) {
125 return FormatString(msg: "%1.4e", time);
126 }
127 return FormatString(msg: "%10.0f", time);
128}
129
130BENCHMARK_EXPORT
131void ConsoleReporter::PrintRunData(const Run& result) {
132 typedef void(PrinterFn)(std::ostream&, LogColor, const char*, ...);
133 auto& Out = GetOutputStream();
134 PrinterFn* printer = (output_options_ & OO_Color)
135 ? static_cast<PrinterFn*>(ColorPrintf)
136 : IgnoreColorPrint;
137 auto name_color =
138 (result.report_big_o || result.report_rms) ? COLOR_BLUE : COLOR_GREEN;
139 printer(Out, name_color, "%-*s ", name_field_width_,
140 result.benchmark_name().c_str());
141
142 if (internal::SkippedWithError == result.skipped) {
143 printer(Out, COLOR_RED, "ERROR OCCURRED: \'%s\'",
144 result.skip_message.c_str());
145 printer(Out, COLOR_DEFAULT, "\n");
146 return;
147 } else if (internal::SkippedWithMessage == result.skipped) {
148 printer(Out, COLOR_WHITE, "SKIPPED: \'%s\'", result.skip_message.c_str());
149 printer(Out, COLOR_DEFAULT, "\n");
150 return;
151 }
152
153 const double real_time = result.GetAdjustedRealTime();
154 const double cpu_time = result.GetAdjustedCPUTime();
155 const std::string real_time_str = FormatTime(time: real_time);
156 const std::string cpu_time_str = FormatTime(time: cpu_time);
157
158 if (result.report_big_o) {
159 std::string big_o = GetBigOString(complexity: result.complexity);
160 printer(Out, COLOR_YELLOW, "%10.2f %-4s %10.2f %-4s ", real_time,
161 big_o.c_str(), cpu_time, big_o.c_str());
162 } else if (result.report_rms) {
163 printer(Out, COLOR_YELLOW, "%10.0f %-4s %10.0f %-4s ", real_time * 100, "%",
164 cpu_time * 100, "%");
165 } else if (result.run_type != Run::RT_Aggregate ||
166 result.aggregate_unit == StatisticUnit::kTime) {
167 const char* timeLabel = GetTimeUnitString(unit: result.time_unit);
168 printer(Out, COLOR_YELLOW, "%s %-4s %s %-4s ", real_time_str.c_str(),
169 timeLabel, cpu_time_str.c_str(), timeLabel);
170 } else {
171 assert(result.aggregate_unit == StatisticUnit::kPercentage);
172 printer(Out, COLOR_YELLOW, "%10.2f %-4s %10.2f %-4s ",
173 (100. * result.real_accumulated_time), "%",
174 (100. * result.cpu_accumulated_time), "%");
175 }
176
177 if (!result.report_big_o && !result.report_rms) {
178 printer(Out, COLOR_CYAN, "%10lld", result.iterations);
179 }
180
181 for (auto& c : result.counters) {
182 const std::size_t cNameLen =
183 std::max(a: std::string::size_type(10), b: c.first.length());
184 std::string s;
185 const char* unit = "";
186 if (result.run_type == Run::RT_Aggregate &&
187 result.aggregate_unit == StatisticUnit::kPercentage) {
188 s = StrFormat(format: "%.2f", 100. * c.second.value);
189 unit = "%";
190 } else {
191 s = HumanReadableNumber(n: c.second.value, one_k: c.second.oneK);
192 if (c.second.flags & Counter::kIsRate)
193 unit = (c.second.flags & Counter::kInvert) ? "s" : "/s";
194 }
195 if (output_options_ & OO_Tabular) {
196 printer(Out, COLOR_DEFAULT, " %*s%s", cNameLen - strlen(s: unit), s.c_str(),
197 unit);
198 } else {
199 printer(Out, COLOR_DEFAULT, " %s=%s%s", c.first.c_str(), s.c_str(), unit);
200 }
201 }
202
203 if (!result.report_label.empty()) {
204 printer(Out, COLOR_DEFAULT, " %s", result.report_label.c_str());
205 }
206
207 printer(Out, COLOR_DEFAULT, "\n");
208}
209
210} // end namespace benchmark
211

source code of third-party/benchmark/src/console_reporter.cc