Machine-readable TurboFan compiler statistics

src/compilation-statistics.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <ostream>  // NOLINT(readability/streams)
 #include <vector>
 
 #include "src/base/platform/platform.h"
 #include "src/compilation-statistics.h"
 
@@ skipping 36 matching lines @@
 void CompilationStatistics::BasicStats::Accumulate(const BasicStats& stats) {
   delta_ += stats.delta_;
   total_allocated_bytes_ += stats.total_allocated_bytes_;
   if (stats.absolute_max_allocated_bytes_ > absolute_max_allocated_bytes_) {
     absolute_max_allocated_bytes_ = stats.absolute_max_allocated_bytes_;
     max_allocated_bytes_ = stats.max_allocated_bytes_;
     function_name_ = stats.function_name_;
   }
 }
 
-
-static void WriteLine(std::ostream& os, const char* name,
+static void WriteLine(std::ostream& os, bool machine_format, const char* name,
                       const CompilationStatistics::BasicStats& stats,
                       const CompilationStatistics::BasicStats& total_stats) {
   const size_t kBufferSize = 128;
   char buffer[kBufferSize];
 
   double ms = stats.delta_.InMillisecondsF();
   double percent = stats.delta_.PercentOf(total_stats.delta_);
   double size_percent =
       static_cast<double>(stats.total_allocated_bytes_ * 100) /
       static_cast<double>(total_stats.total_allocated_bytes_);
-  base::OS::SNPrintF(buffer, kBufferSize, "%28s %10.3f (%5.1f%%)  %10" PRIuS
-                                          " (%5.1f%%) %10" PRIuS " %10" PRIuS,
-                     name, ms, percent, stats.total_allocated_bytes_,
-                     size_percent, stats.max_allocated_bytes_,
-                     stats.absolute_max_allocated_bytes_);
+  if (machine_format) {
+    base::OS::SNPrintF(buffer, kBufferSize,
+                       "\"%s_time\"=%.3f\n\"%s_space\"=%" PRIuS, name, ms, name,
+                       stats.total_allocated_bytes_);
+    os << buffer;
+  } else {
+    base::OS::SNPrintF(buffer, kBufferSize, "%28s %10.3f (%5.1f%%)  %10" PRIuS
+                                            " (%5.1f%%) %10" PRIuS " %10" PRIuS,
+                       name, ms, percent, stats.total_allocated_bytes_,
+                       size_percent, stats.max_allocated_bytes_,
+                       stats.absolute_max_allocated_bytes_);
 
-  os << buffer;
-  if (stats.function_name_.size() > 0) {
-    os << "   " << stats.function_name_.c_str();
+    os << buffer;
+    if (stats.function_name_.size() > 0) {
+      os << "   " << stats.function_name_.c_str();
+    }
+    os << std::endl;
   }
-  os << std::endl;
 }
 
 
 static void WriteFullLine(std::ostream& os) {
   os << "--------------------------------------------------------"
         "--------------------------------------------------------\n";
 }
 
 
 static void WriteHeader(std::ostream& os) {
@@ skipping 24 matching lines @@
     sorted_phase_kinds[it->second.insert_order_] = it;
   }
 
   typedef std::vector<CompilationStatistics::PhaseMap::const_iterator>
       SortedPhases;
   SortedPhases sorted_phases(s.phase_map_.size());
   for (auto it = s.phase_map_.begin(); it != s.phase_map_.end(); ++it) {
     sorted_phases[it->second.insert_order_] = it;
   }
 
-  WriteHeader(os);
+  if (!s.machine_output()) WriteHeader(os);

[Michael Starzinger, 2016/06/13 08:22:16]

This hard-codes the printing format to be exclusively in one of the two formats.
We could instead parameterize the piping operator by using a struct. I was
thinking along the lines of ...

struct AsPrintableStatistics {
  const CompilationStatistics& s;
  const bool machine_output;
}

std::ostream& operator<<(std::ostream& os, const AsPrintableStatistics& s);

This way the CompilationStatistics data container is decoupled from the
configuration of how to print it. The piping operator could easily be called
twice in different configurations if need be. The call-sites control the
printing configuration directly.

   for (auto phase_kind_it : sorted_phase_kinds) {
     const auto& phase_kind_name = phase_kind_it->first;
-    for (auto phase_it : sorted_phases) {
-      const auto& phase_stats = phase_it->second;
-      if (phase_stats.phase_kind_name_ != phase_kind_name) continue;
-      const auto& phase_name = phase_it->first;
-      WriteLine(os, phase_name.c_str(), phase_stats, s.total_stats_);
+    if (!s.machine_output()) {
+      for (auto phase_it : sorted_phases) {
+        const auto& phase_stats = phase_it->second;
+        if (phase_stats.phase_kind_name_ != phase_kind_name) continue;
+        const auto& phase_name = phase_it->first;
+        WriteLine(os, s.machine_output(), phase_name.c_str(), phase_stats,
+                  s.total_stats_);
+      }
+      WritePhaseKindBreak(os);
     }
-    WritePhaseKindBreak(os);
     const auto& phase_kind_stats = phase_kind_it->second;
-    WriteLine(os, phase_kind_name.c_str(), phase_kind_stats, s.total_stats_);
+    WriteLine(os, s.machine_output(), phase_kind_name.c_str(), phase_kind_stats,
+              s.total_stats_);
     os << std::endl;
   }
-  WriteFullLine(os);
-  WriteLine(os, "totals", s.total_stats_, s.total_stats_);
+
+  if (!s.machine_output()) WriteFullLine(os);
+  WriteLine(os, s.machine_output(), "totals", s.total_stats_, s.total_stats_);
 
   return os;
 }
 
 }  // namespace internal
 }  // namespace v8