[turbofan] add ZonePool to correctly track compiler phase memory usage

src/compiler/pipeline.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/pipeline.h"
 
 #include <sstream>
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/compiler/ast-graph-builder.h"
@@ skipping 12 matching lines @@
 #include "src/compiler/machine-operator-reducer.h"
 #include "src/compiler/phi-reducer.h"
 #include "src/compiler/register-allocator.h"
 #include "src/compiler/schedule.h"
 #include "src/compiler/scheduler.h"
 #include "src/compiler/simplified-lowering.h"
 #include "src/compiler/simplified-operator-reducer.h"
 #include "src/compiler/typer.h"
 #include "src/compiler/value-numbering-reducer.h"
 #include "src/compiler/verifier.h"
+#include "src/compiler/zone-pool.h"
 #include "src/hydrogen.h"
 #include "src/ostreams.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class PhaseStats {
  public:
   enum PhaseKind { CREATE_GRAPH, OPTIMIZATION, CODEGEN };
 
-  PhaseStats(CompilationInfo* info, PhaseKind kind, const char* name)
+  PhaseStats(CompilationInfo* info, ZonePool* zone_pool, PhaseKind kind,
+             const char* name)
       : info_(info),
+        stats_scope_(zone_pool),
         kind_(kind),
         name_(name),
-        size_(info->zone()->allocation_size()) {
+        size_(0) {
     if (FLAG_turbo_stats) {
       timer_.Start();
+      size_ = info_->zone()->allocation_size();
     }
   }
 
   ~PhaseStats() {
     if (FLAG_turbo_stats) {
       base::TimeDelta delta = timer_.Elapsed();
-      size_t bytes = info_->zone()->allocation_size() - size_;
+      size_t bytes = info_->zone()->allocation_size() +
+                     stats_scope_.GetMaxAllocatedBytes() - size_;
       HStatistics* stats = info_->isolate()->GetTStatistics();
       stats->SaveTiming(name_, delta, static_cast<int>(bytes));
 
       switch (kind_) {
         case CREATE_GRAPH:
           stats->IncrementCreateGraph(delta);
           break;
         case OPTIMIZATION:
           stats->IncrementOptimizeGraph(delta);
           break;
         case CODEGEN:
           stats->IncrementGenerateCode(delta);
           break;
       }
     }
   }
 
  private:
   CompilationInfo* info_;
+  ZonePool::StatsScope stats_scope_;
   PhaseKind kind_;
   const char* name_;
   size_t size_;
   base::ElapsedTimer timer_;
 };
 
 
 static inline bool VerifyGraphs() {
 #ifdef DEBUG
   return true;
@@ skipping 134 matching lines @@
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "---------------------------------------------------\n"
        << "Begin compiling method "
        << info()->function()->debug_name()->ToCString().get()
        << " using Turbofan" << std::endl;
     PrintCompilationStart();
   }
 
+  ZonePool zone_pool(isolate());
+
   // Build the graph.
   Graph graph(zone());
   SourcePositionTable source_positions(&graph);
   source_positions.AddDecorator();
   // TODO(turbofan): there is no need to type anything during initial graph
   // construction.  This is currently only needed for the node cache, which the
   // typer could sweep over later.
   Typer typer(&graph, info()->context());
   MachineOperatorBuilder machine;
   CommonOperatorBuilder common(zone());
   JSOperatorBuilder javascript(zone());
   JSGraph jsgraph(&graph, &common, &javascript, &machine);
   Node* context_node;
   {
-    PhaseStats graph_builder_stats(info(), PhaseStats::CREATE_GRAPH,
+    PhaseStats graph_builder_stats(info(), &zone_pool, PhaseStats::CREATE_GRAPH,
                                    "graph builder");
     AstGraphBuilderWithPositions graph_builder(info(), &jsgraph,
                                                &source_positions);
     graph_builder.CreateGraph();
     context_node = graph_builder.GetFunctionContext();
   }
   {
-    PhaseStats phi_reducer_stats(info(), PhaseStats::CREATE_GRAPH,
+    PhaseStats phi_reducer_stats(info(), &zone_pool, PhaseStats::CREATE_GRAPH,
                                  "phi reduction");
     PhiReducer phi_reducer;
     GraphReducer graph_reducer(&graph);
     graph_reducer.AddReducer(&phi_reducer);
     graph_reducer.ReduceGraph();
     // TODO(mstarzinger): Running reducer once ought to be enough for everyone.
     graph_reducer.ReduceGraph();
     graph_reducer.ReduceGraph();
   }
 
@@ skipping 20 matching lines @@
   if (FLAG_print_turbo_replay) {
     GraphReplayPrinter::PrintReplay(&graph);
   }
 
   // Bailout here in case target architecture is not supported.
   if (!SupportedTarget()) return Handle<Code>::null();
 
   if (info()->is_typing_enabled()) {
     {
       // Type the graph.
-      PhaseStats typer_stats(info(), PhaseStats::CREATE_GRAPH, "typer");
+      PhaseStats typer_stats(info(), &zone_pool, PhaseStats::CREATE_GRAPH,
+                             "typer");
       typer.Run();
       VerifyAndPrintGraph(&graph, "Typed");
     }
     {
       // Lower JSOperators where we can determine types.
-      PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
+      PhaseStats lowering_stats(info(), &zone_pool, PhaseStats::CREATE_GRAPH,
                                 "typed lowering");
       SourcePositionTable::Scope pos(&source_positions,
                                      SourcePosition::Unknown());
       ValueNumberingReducer vn_reducer(zone());
       JSTypedLowering lowering(&jsgraph);
       SimplifiedOperatorReducer simple_reducer(&jsgraph);
       GraphReducer graph_reducer(&graph);
       graph_reducer.AddReducer(&vn_reducer);
       graph_reducer.AddReducer(&lowering);
       graph_reducer.AddReducer(&simple_reducer);
       graph_reducer.ReduceGraph();
 
       VerifyAndPrintGraph(&graph, "Lowered typed");
     }
     {
       // Lower simplified operators and insert changes.
-      PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
+      PhaseStats lowering_stats(info(), &zone_pool, PhaseStats::CREATE_GRAPH,
                                 "simplified lowering");
       SourcePositionTable::Scope pos(&source_positions,
                                      SourcePosition::Unknown());
       SimplifiedLowering lowering(&jsgraph);
       lowering.LowerAllNodes();
       ValueNumberingReducer vn_reducer(zone());
       SimplifiedOperatorReducer simple_reducer(&jsgraph);
       GraphReducer graph_reducer(&graph);
       graph_reducer.AddReducer(&vn_reducer);
       graph_reducer.AddReducer(&simple_reducer);
       graph_reducer.ReduceGraph();
 
       VerifyAndPrintGraph(&graph, "Lowered simplified");
     }
     {
       // Lower changes that have been inserted before.
-      PhaseStats lowering_stats(info(), PhaseStats::OPTIMIZATION,
+      PhaseStats lowering_stats(info(), &zone_pool, PhaseStats::OPTIMIZATION,
                                 "change lowering");
       SourcePositionTable::Scope pos(&source_positions,
                                      SourcePosition::Unknown());
       Linkage linkage(info());
       ValueNumberingReducer vn_reducer(zone());
       SimplifiedOperatorReducer simple_reducer(&jsgraph);
       ChangeLowering lowering(&jsgraph, &linkage);
       MachineOperatorReducer mach_reducer(&jsgraph);
       GraphReducer graph_reducer(&graph);
       // TODO(titzer): Figure out if we should run all reducers at once here.
       graph_reducer.AddReducer(&vn_reducer);
       graph_reducer.AddReducer(&simple_reducer);
       graph_reducer.AddReducer(&lowering);
       graph_reducer.AddReducer(&mach_reducer);
       graph_reducer.ReduceGraph();
 
       // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
       VerifyAndPrintGraph(&graph, "Lowered changes", true);
     }
 
     {
       SourcePositionTable::Scope pos(&source_positions,
                                      SourcePosition::Unknown());
-      PhaseStats control_reducer_stats(info(), PhaseStats::CREATE_GRAPH,
-                                       "control reduction");
+      PhaseStats control_reducer_stats(
+          info(), &zone_pool, PhaseStats::CREATE_GRAPH, "control reduction");
       ControlReducer::ReduceGraph(&jsgraph, &common);
 
       VerifyAndPrintGraph(&graph, "Control reduced");
     }
   }
 
   {
     // Lower any remaining generic JSOperators.
-    PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
+    PhaseStats lowering_stats(info(), &zone_pool, PhaseStats::CREATE_GRAPH,
                               "generic lowering");
     SourcePositionTable::Scope pos(&source_positions,
                                    SourcePosition::Unknown());
     JSGenericLowering lowering(info(), &jsgraph);
     GraphReducer graph_reducer(&graph);
     graph_reducer.AddReducer(&lowering);
     graph_reducer.ReduceGraph();
 
     // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
     VerifyAndPrintGraph(&graph, "Lowered generic", true);
   }
 
   source_positions.RemoveDecorator();
 
   Handle<Code> code = Handle<Code>::null();
   {
     // Compute a schedule.
-    Schedule* schedule = ComputeSchedule(&graph);
+    Schedule* schedule = ComputeSchedule(&zone_pool, &graph);
     // Generate optimized code.
-    PhaseStats codegen_stats(info(), PhaseStats::CODEGEN, "codegen");
+    PhaseStats codegen_stats(info(), &zone_pool, PhaseStats::CODEGEN,
+                             "codegen");
     Linkage linkage(info());
     code = GenerateCode(&linkage, &graph, schedule, &source_positions);
     info()->SetCode(code);
   }
 
   // Print optimized code.
   v8::internal::CodeGenerator::PrintCode(code, info());
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "--------------------------------------------------\n"
        << "Finished compiling method "
        << info()->function()->debug_name()->ToCString().get()
        << " using Turbofan" << std::endl;
   }
 
   return code;
 }
 
 
-Schedule* Pipeline::ComputeSchedule(Graph* graph) {
-  PhaseStats schedule_stats(info(), PhaseStats::CODEGEN, "scheduling");
-  Schedule* schedule = Scheduler::ComputeSchedule(graph);
+Schedule* Pipeline::ComputeSchedule(ZonePool* zone_pool, Graph* graph) {
+  PhaseStats schedule_stats(info(), zone_pool, PhaseStats::CODEGEN,
+                            "scheduling");
+  Schedule* schedule = Scheduler::ComputeSchedule(zone_pool, graph);
   TraceSchedule(schedule);
   if (VerifyGraphs()) ScheduleVerifier::Run(schedule);
   return schedule;
 }
 
 
 Handle<Code> Pipeline::GenerateCodeForMachineGraph(Linkage* linkage,
                                                    Graph* graph,
                                                    Schedule* schedule) {
   CHECK(SupportedBackend());
   if (schedule == NULL) {
     // TODO(rossberg): Should this really be untyped?
     VerifyAndPrintGraph(graph, "Machine", true);
-    schedule = ComputeSchedule(graph);
+    ZonePool zone_pool(isolate());
+    schedule = ComputeSchedule(&zone_pool, graph);
   }
   TraceSchedule(schedule);
 
   SourcePositionTable source_positions(graph);
   Handle<Code> code = GenerateCode(linkage, graph, schedule, &source_positions);
 #if ENABLE_DISASSEMBLER
   if (!code.is_null() && FLAG_print_opt_code) {
     CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());
     OFStream os(tracing_scope.file());
     code->Disassemble("test code", os);
@@ skipping 77 matching lines @@
 }
 
 
 void Pipeline::TearDown() {
   InstructionOperand::TearDownCaches();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8