[turbofan] split compilation stats off from HStatistics and track high water marks

R=jarin@chromium.org

BUG=

Review URL: https://codereview.chromium.org/669053002

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24830 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

BUILD.gn

@@ -474,6 +474,8 @@ source_set("v8_base") {
     "src/codegen.h",
     "src/compilation-cache.cc",
     "src/compilation-cache.h",
+    "src/compilation-statistics.cc",
+    "src/compilation-statistics.h",
     "src/compiler/access-builder.cc",
     "src/compiler/access-builder.h",
     "src/compiler/ast-graph-builder.cc",
@@ -560,6 +562,8 @@ source_set("v8_base") {
     "src/compiler/phi-reducer.h",
     "src/compiler/pipeline.cc",
     "src/compiler/pipeline.h",
+    "src/compiler/pipeline-statistics.cc",
+    "src/compiler/pipeline-statistics.h",
     "src/compiler/raw-machine-assembler.cc",
     "src/compiler/raw-machine-assembler.h",
     "src/compiler/register-allocator.cc",

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 <iostream>  // NOLINT(readability/streams)
+#include <vector>
+
+#include "src/base/platform/platform.h"
+#include "src/compilation-statistics.h"
+
+namespace v8 {
+namespace internal {
+
+void CompilationStatistics::RecordPhaseStats(const char* phase_kind_name,
+                                             const char* phase_name,
+                                             const BasicStats& stats) {
+  std::string phase_name_str(phase_name);
+  auto it = phase_map_.find(phase_name_str);
+  if (it == phase_map_.end()) {
+    PhaseStats phase_stats(phase_map_.size(), phase_kind_name);
+    it = phase_map_.insert(std::make_pair(phase_name_str, phase_stats)).first;
+  }
+  it->second.Accumulate(stats);
+}
+
+
+void CompilationStatistics::RecordPhaseKindStats(const char* phase_kind_name,
+                                                 const BasicStats& stats) {
+  std::string phase_kind_name_str(phase_kind_name);
+  auto it = phase_kind_map_.find(phase_kind_name_str);
+  if (it == phase_kind_map_.end()) {
+    PhaseKindStats phase_kind_stats(phase_kind_map_.size());
+    it = phase_kind_map_.insert(std::make_pair(phase_kind_name_str,
+                                               phase_kind_stats)).first;
+  }
+  it->second.Accumulate(stats);
+}
+
+
+void CompilationStatistics::RecordTotalStats(size_t source_size,
+                                             const BasicStats& stats) {
+  source_size += source_size;
+  total_stats_.Accumulate(stats);
+}
+
+
+void CompilationStatistics::BasicStats::Accumulate(const BasicStats& stats) {
+  delta_ += stats.delta_;
+  total_allocated_bytes_ += stats.total_allocated_bytes_;
+  if (stats.max_allocated_bytes_ > max_allocated_bytes_) {
+    max_allocated_bytes_ = stats.max_allocated_bytes_;
+    function_name_ = stats.function_name_;
+  }
+}
+
+
+static void WriteLine(std::ostream& os, 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 ms / %5.1f %% %10u total / %5.1f %% %10u max",
+                     name, ms, percent, stats.total_allocated_bytes_,
+                     size_percent, stats.max_allocated_bytes_);
+
+  os << buffer;
+  if (stats.function_name_.size() > 0) {
+    os << " : " << stats.function_name_.c_str();
+  }
+  os << std::endl;
+}
+
+
+static void WriteFullLine(std::ostream& os) {
+  os << "-----------------------------------------------"
+        "-----------------------------------------------\n";
+}
+
+
+static void WriteHeader(std::ostream& os) {
+  WriteFullLine(os);
+  os << "                             Turbofan timing results:\n";
+  WriteFullLine(os);
+}
+
+
+static void WritePhaseKindBreak(std::ostream& os) {
+  os << "                             ------------------"
+        "-----------------------------------------------\n";
+}
+
+
+std::ostream& operator<<(std::ostream& os, const CompilationStatistics& s) {
+  // phase_kind_map_ and phase_map_ don't get mutated, so store a bunch of
+  // pointers into them.
+
+  typedef std::vector<CompilationStatistics::PhaseKindMap::const_iterator>
+      SortedPhaseKinds;
+  SortedPhaseKinds sorted_phase_kinds(s.phase_kind_map_.size());
+  for (auto it = s.phase_kind_map_.begin(); it != s.phase_kind_map_.end();
+       ++it) {
+    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);
+  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_);
+    }
+    WritePhaseKindBreak(os);
+    const auto& phase_kind_stats = phase_kind_it->second;
+    WriteLine(os, 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_);
+
+  return os;
+}
+
+}  // namespace internal
+}  // namespace v8

src/compilation-statistics.h

+// 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.
+
+#ifndef V8_COMPILATION_STATISTICS_H_
+#define V8_COMPILATION_STATISTICS_H_
+
+#include <map>
+#include <string>
+
+#include "src/allocation.h"
+#include "src/base/platform/time.h"
+
+namespace v8 {
+namespace internal {
+
+class CompilationInfo;
+
+class CompilationStatistics FINAL : public Malloced {
+ public:
+  CompilationStatistics() {}
+
+  class BasicStats {
+   public:
+    BasicStats() : total_allocated_bytes_(0), max_allocated_bytes_(0) {}
+
+    void Accumulate(const BasicStats& stats);
+
+    base::TimeDelta delta_;
+    size_t total_allocated_bytes_;
+    size_t max_allocated_bytes_;
+    std::string function_name_;
+  };
+
+  void RecordPhaseStats(const char* phase_kind_name, const char* phase_name,
+                        const BasicStats& stats);
+
+  void RecordPhaseKindStats(const char* phase_kind_name,
+                            const BasicStats& stats);
+
+  void RecordTotalStats(size_t source_size, const BasicStats& stats);
+
+ private:
+  class TotalStats : public BasicStats {
+   public:
+    TotalStats() : source_size_(0) {}
+    uint64_t source_size_;
+  };
+
+  class OrderedStats : public BasicStats {
+   public:
+    explicit OrderedStats(size_t insert_order) : insert_order_(insert_order) {}
+    size_t insert_order_;
+  };
+
+  class PhaseStats : public OrderedStats {
+   public:
+    PhaseStats(size_t insert_order, const char* phase_kind_name)
+        : OrderedStats(insert_order), phase_kind_name_(phase_kind_name) {}
+    std::string phase_kind_name_;
+  };
+
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const CompilationStatistics& s);
+
+  typedef OrderedStats PhaseKindStats;
+  typedef std::map<std::string, PhaseKindStats> PhaseKindMap;
+  typedef std::map<std::string, PhaseStats> PhaseMap;
+
+  TotalStats total_stats_;
+  PhaseKindMap phase_kind_map_;
+  PhaseMap phase_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(CompilationStatistics);
+};
+
+std::ostream& operator<<(std::ostream& os, const CompilationStatistics& s);
+
+}  // namespace internal
+}  // namespace v8
+
+#endif

src/compiler/pipeline-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 "src/compiler.h"
+#include "src/compiler/pipeline-statistics.h"
+#include "src/compiler/zone-pool.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+void PipelineStatistics::CommonStats::Begin(
+    PipelineStatistics* pipeline_stats) {
+  DCHECK(scope_.is_empty());
+  scope_.Reset(new ZonePool::StatsScope(pipeline_stats->zone_pool_));
+  timer_.Start();
+  outer_zone_initial_size_ = pipeline_stats->OuterZoneSize();
+}
+
+
+void PipelineStatistics::CommonStats::End(
+    PipelineStatistics* pipeline_stats,
+    CompilationStatistics::BasicStats* diff) {
+  DCHECK(!scope_.is_empty());
+  diff->function_name_ = pipeline_stats->function_name_;
+  diff->delta_ = timer_.Elapsed();
+  size_t outer_zone_diff =
+      pipeline_stats->OuterZoneSize() - outer_zone_initial_size_;
+  diff->max_allocated_bytes_ = outer_zone_diff + scope_->GetMaxAllocatedBytes();
+  diff->total_allocated_bytes_ =
+      outer_zone_diff + scope_->GetTotalAllocatedBytes();
+  scope_.Reset(NULL);
+  timer_.Stop();
+}
+
+
+PipelineStatistics::PipelineStatistics(CompilationInfo* info,
+                                       ZonePool* zone_pool)
+    : isolate_(info->zone()->isolate()),
+      outer_zone_(info->zone()),
+      zone_pool_(zone_pool),
+      compilation_stats_(isolate_->GetTurboStatistics()),
+      source_size_(0),
+      phase_kind_name_(NULL),
+      phase_name_(NULL) {
+  if (!info->shared_info().is_null()) {
+    source_size_ = static_cast<size_t>(info->shared_info()->SourceSize());
+    SmartArrayPointer<char> name =
+        info->shared_info()->DebugName()->ToCString();
+    function_name_ = name.get();
+  }
+  total_stats_.Begin(this);
+}
+
+
+PipelineStatistics::~PipelineStatistics() {
+  if (InPhaseKind()) EndPhaseKind();
+  CompilationStatistics::BasicStats diff;
+  total_stats_.End(this, &diff);
+  compilation_stats_->RecordTotalStats(source_size_, diff);
+}
+
+
+void PipelineStatistics::BeginPhaseKind(const char* phase_kind_name) {
+  DCHECK(!InPhase());
+  if (InPhaseKind()) EndPhaseKind();
+  phase_kind_name_ = phase_kind_name;
+  phase_kind_stats_.Begin(this);
+}
+
+
+void PipelineStatistics::EndPhaseKind() {
+  DCHECK(!InPhase());
+  CompilationStatistics::BasicStats diff;
+  phase_kind_stats_.End(this, &diff);
+  compilation_stats_->RecordPhaseKindStats(phase_kind_name_, diff);
+}
+
+
+void PipelineStatistics::BeginPhase(const char* name) {
+  DCHECK(InPhaseKind());
+  phase_name_ = name;
+  phase_stats_.Begin(this);
+}
+
+
+void PipelineStatistics::EndPhase() {
+  DCHECK(InPhaseKind());
+  CompilationStatistics::BasicStats diff;
+  phase_stats_.End(this, &diff);
+  compilation_stats_->RecordPhaseStats(phase_kind_name_, phase_name_, diff);
+}
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8

src/compiler/pipeline-statistics.h

+// 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.
+
+#ifndef V8_COMPILER_PIPELINE_STATISTICS_H_
+#define V8_COMPILER_PIPELINE_STATISTICS_H_
+
+#include <string>
+
+#include "src/compilation-statistics.h"
+#include "src/compiler/zone-pool.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class PhaseScope;
+
+class PipelineStatistics : public Malloced {
+ public:
+  PipelineStatistics(CompilationInfo* info, ZonePool* zone_pool);
+  ~PipelineStatistics();
+
+  void BeginPhaseKind(const char* phase_kind_name);
+
+ private:
+  size_t OuterZoneSize() {
+    return static_cast<size_t>(outer_zone_->allocation_size());
+  }
+
+  class CommonStats {
+   public:
+    CommonStats() : outer_zone_initial_size_(0) {}
+
+    void Begin(PipelineStatistics* pipeline_stats);
+    void End(PipelineStatistics* pipeline_stats,
+             CompilationStatistics::BasicStats* diff);
+
+    SmartPointer<ZonePool::StatsScope> scope_;
+    base::ElapsedTimer timer_;
+    size_t outer_zone_initial_size_;
+  };
+
+  bool InPhaseKind() { return !phase_kind_stats_.scope_.is_empty(); }
+  void EndPhaseKind();
+
+  friend class PhaseScope;
+  bool InPhase() { return !phase_stats_.scope_.is_empty(); }
+  void BeginPhase(const char* name);
+  void EndPhase();
+
+  Isolate* isolate_;
+  Zone* outer_zone_;
+  ZonePool* zone_pool_;
+  CompilationStatistics* compilation_stats_;
+  std::string function_name_;
+
+  // Stats for the entire compilation.
+  CommonStats total_stats_;
+  size_t source_size_;
+
+  // Stats for phase kind.
+  const char* phase_kind_name_;
+  CommonStats phase_kind_stats_;
+
+  // Stats for phase.
+  const char* phase_name_;
+  CommonStats phase_stats_;
+
+  DISALLOW_COPY_AND_ASSIGN(PipelineStatistics);
+};
+
+
+class PhaseScope {
+ public:
+  PhaseScope(PipelineStatistics* pipeline_stats, const char* name)
+      : pipeline_stats_(pipeline_stats) {
+    if (pipeline_stats_ != NULL) pipeline_stats_->BeginPhase(name);
+  }
+  ~PhaseScope() {
+    if (pipeline_stats_ != NULL) pipeline_stats_->EndPhase();
+  }
+
+ private:
+  PipelineStatistics* const pipeline_stats_;
+
+  DISALLOW_COPY_AND_ASSIGN(PhaseScope);
+};
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8
+
+#endif

src/compiler/pipeline.h

@@ -22,6 +22,7 @@ namespace compiler {
 class Graph;
 class InstructionSequence;
 class Linkage;
+class PipelineStatistics;
 class RegisterAllocator;
 class Schedule;
 class SourcePositionTable;
@@ -61,7 +62,8 @@ class Pipeline {
   void PrintAllocator(const char* phase, const RegisterAllocator* allocator);
   void VerifyAndPrintGraph(Graph* graph, const char* phase,
                            bool untyped = false);
-  Handle<Code> GenerateCode(ZonePool* zone_pool, Linkage* linkage, Graph* graph,
+  Handle<Code> GenerateCode(PipelineStatistics* pipeline_statistics,
+                            ZonePool* zone_pool, Linkage* linkage, Graph* graph,
                             Schedule* schedule,
                             SourcePositionTable* source_positions);
 };

src/compiler/register-allocator.cc

@@ -2,10 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "src/compiler/register-allocator.h"
-
 #include "src/compiler/linkage.h"
-#include "src/hydrogen.h"
+#include "src/compiler/pipeline-statistics.h"
+#include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
@@ -503,7 +502,6 @@ RegisterAllocator::RegisterAllocator(Zone* local_zone, Frame* frame,
                                      CompilationInfo* info,
                                      InstructionSequence* code)
     : zone_(local_zone),
-      zone_pool_(NULL),
       frame_(frame),
       info_(info),
       code_(code),
@@ -1096,72 +1094,53 @@ void RegisterAllocator::ResolvePhis(const InstructionBlock* block) {
 }
 
 
-bool RegisterAllocator::Allocate(ZonePool* zone_pool) {
-  DCHECK_EQ(NULL, zone_pool_);
-  zone_pool_ = zone_pool;
+bool RegisterAllocator::Allocate(PipelineStatistics* stats) {
   assigned_registers_ = new (code_zone())
       BitVector(Register::NumAllocatableRegisters(), code_zone());
   assigned_double_registers_ = new (code_zone())
       BitVector(DoubleRegister::NumAllocatableAliasedRegisters(), code_zone());
-  MeetRegisterConstraints();
+  {
+    PhaseScope phase_scope(stats, "meet register constraints");
+    MeetRegisterConstraints();
+  }
   if (!AllocationOk()) return false;
-  ResolvePhis();
-  BuildLiveRanges();
-  AllocateGeneralRegisters();
+  {
+    PhaseScope phase_scope(stats, "resolve phis");
+    ResolvePhis();
+  }
+  {
+    PhaseScope phase_scope(stats, "build live ranges");
+    BuildLiveRanges();
+  }
+  {
+    PhaseScope phase_scope(stats, "allocate general registers");
+    AllocateGeneralRegisters();
+  }
   if (!AllocationOk()) return false;
-  AllocateDoubleRegisters();
+  {
+    PhaseScope phase_scope(stats, "allocate double registers");
+    AllocateDoubleRegisters();
+  }
   if (!AllocationOk()) return false;
-  PopulatePointerMaps();
-  ConnectRanges();
-  ResolveControlFlow();
+  {
+    PhaseScope phase_scope(stats, "populate pointer maps");
+    PopulatePointerMaps();
+  }
+  {
+    PhaseScope phase_scope(stats, "connect ranges");
+    ConnectRanges();
+  }
+  {
+    PhaseScope phase_scope(stats, "resolve control flow");
+    ResolveControlFlow();
+  }
   frame()->SetAllocatedRegisters(assigned_registers_);
   frame()->SetAllocatedDoubleRegisters(assigned_double_registers_);
   return true;
 }
 
 
-class RegisterAllocatorPhase : public CompilationPhase {
- public:
-  RegisterAllocatorPhase(const char* name, RegisterAllocator* allocator)
-      : CompilationPhase(name, allocator->info()),
-        allocator_(allocator),
-        allocator_zone_start_allocation_size_(0),
-        stats_(NULL) {
-    if (FLAG_turbo_stats) {
-      allocator_zone_start_allocation_size_ =
-          allocator->info()->zone()->allocation_size();
-      if (allocator->zone_pool() != NULL) {
-        stats_ = new ZonePool::StatsScope(allocator->zone_pool());
-      }
-    }
-  }
-
-  ~RegisterAllocatorPhase() {
-    if (FLAG_turbo_stats) {
-      unsigned size = allocator_->info()->zone()->allocation_size() -
-                      allocator_zone_start_allocation_size_;
-      if (stats_ != NULL) {
-        size += static_cast<unsigned>(stats_->GetMaxAllocatedBytes());
-      }
-      isolate()->GetTStatistics()->SaveTiming(name(), base::TimeDelta(), size);
-    }
-    delete stats_;
-#ifdef DEBUG
-    if (allocator_ != NULL) allocator_->Verify();
-#endif
-  }
-
- private:
-  RegisterAllocator* allocator_;
-  unsigned allocator_zone_start_allocation_size_;
-  ZonePool::StatsScope* stats_;
-
-  DISALLOW_COPY_AND_ASSIGN(RegisterAllocatorPhase);
-};
-
-
 void RegisterAllocator::MeetRegisterConstraints() {
-  RegisterAllocatorPhase phase("L_Register constraints", this);
   for (int i = 0; i < code()->InstructionBlockCount(); ++i) {
     MeetRegisterConstraints(
         code()->InstructionBlockAt(BasicBlock::RpoNumber::FromInt(i)));
@@ -1171,8 +1150,6 @@ void RegisterAllocator::MeetRegisterConstraints() {
 
 
 void RegisterAllocator::ResolvePhis() {
-  RegisterAllocatorPhase phase("L_Resolve phis", this);
-
   // Process the blocks in reverse order.
   for (int i = code()->InstructionBlockCount() - 1; i >= 0; --i) {
     ResolvePhis(code()->InstructionBlockAt(BasicBlock::RpoNumber::FromInt(i)));
@@ -1250,7 +1227,6 @@ const InstructionBlock* RegisterAllocator::GetInstructionBlock(
 
 
 void RegisterAllocator::ConnectRanges() {
-  RegisterAllocatorPhase phase("L_Connect ranges", this);
   for (int i = 0; i < live_ranges()->length(); ++i) {
     LiveRange* first_range = live_ranges()->at(i);
     if (first_range == NULL || first_range->parent() != NULL) continue;
@@ -1294,7 +1270,6 @@ bool RegisterAllocator::CanEagerlyResolveControlFlow(
 
 
 void RegisterAllocator::ResolveControlFlow() {
-  RegisterAllocatorPhase phase("L_Resolve control flow", this);
   for (int block_id = 1; block_id < code()->InstructionBlockCount();
        ++block_id) {
     const InstructionBlock* block =
@@ -1316,7 +1291,6 @@ void RegisterAllocator::ResolveControlFlow() {
 
 
 void RegisterAllocator::BuildLiveRanges() {
-  RegisterAllocatorPhase phase("L_Build live ranges", this);
   InitializeLivenessAnalysis();
   // Process the blocks in reverse order.
   for (int block_id = code()->InstructionBlockCount() - 1; block_id >= 0;
@@ -1457,8 +1431,6 @@ bool RegisterAllocator::SafePointsAreInOrder() const {
 
 
 void RegisterAllocator::PopulatePointerMaps() {
-  RegisterAllocatorPhase phase("L_Populate pointer maps", this);
-
   DCHECK(SafePointsAreInOrder());
 
   // Iterate over all safe point positions and record a pointer
@@ -1541,7 +1513,6 @@ void RegisterAllocator::PopulatePointerMaps() {
 
 
 void RegisterAllocator::AllocateGeneralRegisters() {
-  RegisterAllocatorPhase phase("L_Allocate general registers", this);
   num_registers_ = Register::NumAllocatableRegisters();
   mode_ = GENERAL_REGISTERS;
   AllocateRegisters();
@@ -1549,7 +1520,6 @@ void RegisterAllocator::AllocateGeneralRegisters() {
 
 
 void RegisterAllocator::AllocateDoubleRegisters() {
-  RegisterAllocatorPhase phase("L_Allocate double registers", this);
   num_registers_ = DoubleRegister::NumAllocatableAliasedRegisters();
   mode_ = DOUBLE_REGISTERS;
   AllocateRegisters();

src/compiler/register-allocator.h

@@ -23,6 +23,8 @@ class PointerMap;
 
 namespace compiler {
 
+class PipelineStatistics;
+
 enum RegisterKind {
   UNALLOCATED_REGISTERS,
   GENERAL_REGISTERS,
@@ -331,8 +333,7 @@ class RegisterAllocator BASE_EMBEDDED {
   // Returns the register kind required by the given virtual register.
   RegisterKind RequiredRegisterKind(int virtual_register) const;
 
-  // TODO(dcarney): fix compilation phase stats to not require this.
-  bool Allocate(ZonePool* zone_pool = NULL);
+  bool Allocate(PipelineStatistics* stats = NULL);
 
   const ZoneList<LiveRange*>* live_ranges() const { return &live_ranges_; }
   const Vector<LiveRange*>* fixed_live_ranges() const {
@@ -344,7 +345,6 @@ class RegisterAllocator BASE_EMBEDDED {
 
   CompilationInfo* info() const { return info_; }
   inline InstructionSequence* code() const { return code_; }
-  ZonePool* zone_pool() const { return zone_pool_; }
 
   // This zone is for datastructures only needed during register allocation.
   inline Zone* zone() const { return zone_; }
@@ -501,8 +501,6 @@ class RegisterAllocator BASE_EMBEDDED {
   Frame* frame() const { return frame_; }
 
   Zone* const zone_;
-  // TODO(dcarney): remove this.
-  ZonePool* zone_pool_;
   Frame* const frame_;
   CompilationInfo* const info_;
   InstructionSequence* const code_;

src/compiler/zone-pool.cc

@@ -9,7 +9,9 @@ namespace internal {
 namespace compiler {
 
 ZonePool::StatsScope::StatsScope(ZonePool* zone_pool)
-    : zone_pool_(zone_pool), max_allocated_bytes_(0) {
+    : zone_pool_(zone_pool),
+      total_allocated_bytes_at_start_(zone_pool->GetTotalAllocatedBytes()),
+      max_allocated_bytes_(0) {
   zone_pool_->stats_.push_back(this);
   for (auto zone : zone_pool_->used_) {
     size_t size = static_cast<size_t>(zone->allocation_size());
@@ -46,6 +48,11 @@ size_t ZonePool::StatsScope::GetCurrentAllocatedBytes() {
 }
 
 
+size_t ZonePool::StatsScope::GetTotalAllocatedBytes() {
+  return zone_pool_->GetTotalAllocatedBytes() - total_allocated_bytes_at_start_;
+}
+
+
 void ZonePool::StatsScope::ZoneReturned(Zone* zone) {
   size_t current_total = GetCurrentAllocatedBytes();
   // Update max.

src/compiler/zone-pool.h

@@ -44,6 +44,7 @@ class ZonePool FINAL {
 
     size_t GetMaxAllocatedBytes();
     size_t GetCurrentAllocatedBytes();
+    size_t GetTotalAllocatedBytes();
 
    private:
     friend class ZonePool;
@@ -53,6 +54,7 @@ class ZonePool FINAL {
 
     ZonePool* const zone_pool_;
     InitialValues initial_values_;
+    size_t total_allocated_bytes_at_start_;
     size_t max_allocated_bytes_;
 
     DISALLOW_COPY_AND_ASSIGN(StatsScope);

src/hydrogen.cc

@@ -12594,15 +12594,14 @@ void HStatistics::Initialize(CompilationInfo* info) {
 }
 
 
-void HStatistics::Print(const char* stats_name) {
+void HStatistics::Print() {
   PrintF(
       "\n"
       "----------------------------------------"
       "----------------------------------------\n"
-      "--- %s timing results:\n"
+      "--- Hydrogen timing results:\n"
       "----------------------------------------"
-      "----------------------------------------\n",
-      stats_name);
+      "----------------------------------------\n");
   base::TimeDelta sum;
   for (int i = 0; i < times_.length(); ++i) {
     sum += times_[i];

src/hydrogen.h

@@ -2760,7 +2760,7 @@ class HStatistics FINAL: public Malloced {
         source_size_(0) { }
 
   void Initialize(CompilationInfo* info);
-  void Print(const char* stats_name);
+  void Print();
   void SaveTiming(const char* name, base::TimeDelta time, unsigned size);
 
   void IncrementFullCodeGen(base::TimeDelta full_code_gen) {

src/isolate.cc

@@ -5,6 +5,7 @@
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
+#include <iostream>  // NOLINT(readability/streams)
 
 #include "src/v8.h"
 
@@ -16,6 +17,7 @@
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
 #include "src/compilation-cache.h"
+#include "src/compilation-statistics.h"
 #include "src/cpu-profiler.h"
 #include "src/debug.h"
 #include "src/deoptimizer.h"
@@ -1606,8 +1608,10 @@ void Isolate::Deinit() {
     heap_.mark_compact_collector()->EnsureSweepingCompleted();
   }
 
-  if (FLAG_turbo_stats) GetTStatistics()->Print("TurboFan");
-  if (FLAG_hydrogen_stats) GetHStatistics()->Print("Hydrogen");
+  if (turbo_statistics() != NULL) {
+    std::cout << *turbo_statistics() << std::endl;
+  }
+  if (FLAG_hydrogen_stats) GetHStatistics()->Print();
 
   if (FLAG_print_deopt_stress) {
     PrintF(stdout, "=== Stress deopt counter: %u\n", stress_deopt_count_);
@@ -2119,9 +2123,10 @@ HStatistics* Isolate::GetHStatistics() {
 }
 
 
-HStatistics* Isolate::GetTStatistics() {
-  if (tstatistics() == NULL) set_tstatistics(new HStatistics());
-  return tstatistics();
+CompilationStatistics* Isolate::GetTurboStatistics() {
+  if (turbo_statistics() == NULL)
+    set_turbo_statistics(new CompilationStatistics());
+  return turbo_statistics();
 }
 
 

src/isolate.h

@@ -40,6 +40,7 @@ class CodeRange;
 class CodeStubDescriptor;
 class CodeTracer;
 class CompilationCache;
+class CompilationStatistics;
 class ContextSlotCache;
 class Counters;
 class CpuFeatures;
@@ -383,7 +384,7 @@ typedef List<HeapObject*> DebugObjectCache;
   V(int, pending_microtask_count, 0)                                           \
   V(bool, autorun_microtasks, true)                                            \
   V(HStatistics*, hstatistics, NULL)                                           \
-  V(HStatistics*, tstatistics, NULL)                                           \
+  V(CompilationStatistics*, turbo_statistics, NULL)                            \
   V(HTracer*, htracer, NULL)                                                   \
   V(CodeTracer*, code_tracer, NULL)                                            \
   V(bool, fp_stubs_generated, false)                                           \
@@ -1052,7 +1053,7 @@ class Isolate {
   int id() const { return static_cast<int>(id_); }
 
   HStatistics* GetHStatistics();
-  HStatistics* GetTStatistics();
+  CompilationStatistics* GetTurboStatistics();
   HTracer* GetHTracer();
   CodeTracer* GetCodeTracer();
 

test/unittests/compiler/zone-pool-unittest.cc

@@ -23,9 +23,11 @@ class ZonePoolTest : public TestWithIsolate {
     ASSERT_EQ(total, zone_pool()->GetTotalAllocatedBytes());
   }
 
-  void Expect(ZonePool::StatsScope* stats, size_t current, size_t max) {
+  void Expect(ZonePool::StatsScope* stats, size_t current, size_t max,
+              size_t total) {
     ASSERT_EQ(current, stats->GetCurrentAllocatedBytes());
     ASSERT_EQ(max, stats->GetMaxAllocatedBytes());
+    ASSERT_EQ(total, stats->GetTotalAllocatedBytes());
   }
 
   size_t Allocate(Zone* zone) {
@@ -45,7 +47,7 @@ TEST_F(ZonePoolTest, Empty) {
   ExpectForPool(0, 0, 0);
   {
     ZonePool::StatsScope stats(zone_pool());
-    Expect(&stats, 0, 0);
+    Expect(&stats, 0, 0, 0);
   }
   ExpectForPool(0, 0, 0);
   {
@@ -77,7 +79,7 @@ TEST_F(ZonePoolTest, MultipleZonesWithDeletion) {
     before_deletion += Allocate(scopes[i]->zone());  // Add some stuff.
   }
 
-  Expect(&stats, before_deletion, before_deletion);
+  Expect(&stats, before_deletion, before_deletion, before_deletion);
   ExpectForPool(before_stats + before_deletion, before_stats + before_deletion,
                 before_stats + before_deletion);
 
@@ -87,7 +89,7 @@ TEST_F(ZonePoolTest, MultipleZonesWithDeletion) {
     scopes[i] = new ZonePool::Scope(zone_pool());
   }
 
-  Expect(&stats, 0, before_deletion);
+  Expect(&stats, 0, before_deletion, before_deletion);
   ExpectForPool(0, before_stats + before_deletion,
                 before_stats + before_deletion);
 
@@ -96,7 +98,8 @@ TEST_F(ZonePoolTest, MultipleZonesWithDeletion) {
     after_deletion += Allocate(scopes[i]->zone());  // Add some stuff.
   }
 
-  Expect(&stats, after_deletion, std::max(after_deletion, before_deletion));
+  Expect(&stats, after_deletion, std::max(after_deletion, before_deletion),
+         before_deletion + after_deletion);
   ExpectForPool(after_deletion,
                 std::max(after_deletion, before_stats + before_deletion),
                 before_stats + before_deletion + after_deletion);
@@ -106,7 +109,8 @@ TEST_F(ZonePoolTest, MultipleZonesWithDeletion) {
     delete scopes[i];
   }
 
-  Expect(&stats, 0, std::max(after_deletion, before_deletion));
+  Expect(&stats, 0, std::max(after_deletion, before_deletion),
+         before_deletion + after_deletion);
   ExpectForPool(0, std::max(after_deletion, before_stats + before_deletion),
                 before_stats + before_deletion + after_deletion);
 }
@@ -136,19 +140,20 @@ TEST_F(ZonePoolTest, SimpleAllocationLoop) {
           total_allocated += bytes;
           max_loop_allocation =
               std::max(max_loop_allocation, outer_allocated + allocated);
-          Expect(&inner_stats, allocated, allocated);
-          Expect(&outer_stats, outer_allocated + allocated,
-                 max_loop_allocation);
+          Expect(&inner_stats, allocated, allocated, allocated);
+          Expect(&outer_stats, outer_allocated + allocated, max_loop_allocation,
+                 total_allocated);
           ExpectForPool(outer_allocated + allocated, max_loop_allocation,
                         total_allocated);
         }
       }
-      Expect(&inner_stats, 0, allocated);
-      Expect(&outer_stats, outer_allocated, max_loop_allocation);
+      Expect(&inner_stats, 0, allocated, allocated);
+      Expect(&outer_stats, outer_allocated, max_loop_allocation,
+             total_allocated);
       ExpectForPool(outer_allocated, max_loop_allocation, total_allocated);
     }
   }
-  Expect(&outer_stats, 0, max_loop_allocation);
+  Expect(&outer_stats, 0, max_loop_allocation, total_allocated);
   ExpectForPool(0, max_loop_allocation, total_allocated);
 }
 

tools/gyp/v8.gyp

@@ -387,6 +387,8 @@
         '../../src/codegen.h',
         '../../src/compilation-cache.cc',
         '../../src/compilation-cache.h',
+        '../../src/compilation-statistics.cc',
+        '../../src/compilation-statistics.h',
         '../../src/compiler/access-builder.cc',
         '../../src/compiler/access-builder.h',
         '../../src/compiler/ast-graph-builder.cc',
@@ -473,6 +475,8 @@
         '../../src/compiler/phi-reducer.h',
         '../../src/compiler/pipeline.cc',
         '../../src/compiler/pipeline.h',
+        '../../src/compiler/pipeline-statistics.cc',
+        '../../src/compiler/pipeline-statistics.h',
         '../../src/compiler/raw-machine-assembler.cc',
         '../../src/compiler/raw-machine-assembler.h',
         '../../src/compiler/register-allocator.cc',