utils/benchmark/src/console_reporter.cc

   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