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
34namespace benchmark {
35
36bool 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
55void 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
72void 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
93static 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
101void 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