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

src/compiler/scheduler.cc

 // Copyright 2013 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 <deque>
 #include <queue>
 
 #include "src/compiler/scheduler.h"
 
 #include "src/compiler/graph.h"
@@ skipping 10 matching lines @@
 static inline void Trace(const char* msg, ...) {
   if (FLAG_trace_turbo_scheduler) {
     va_list arguments;
     va_start(arguments, msg);
     base::OS::VPrint(msg, arguments);
     va_end(arguments);
   }
 }
 
 
-Scheduler::Scheduler(Zone* zone, Graph* graph, Schedule* schedule)
-    : zone_(zone),
+Scheduler::Scheduler(ZonePool* zone_pool, Zone* zone, Graph* graph,
+                     Schedule* schedule)
+    : zone_pool_(zone_pool),
+      zone_(zone),
       graph_(graph),
       schedule_(schedule),
       scheduled_nodes_(zone),
       schedule_root_nodes_(zone),
       node_data_(graph_->NodeCount(), DefaultSchedulerData(), zone),
       has_floating_control_(false) {}
 
 
-Schedule* Scheduler::ComputeSchedule(Graph* graph) {
+Schedule* Scheduler::ComputeSchedule(ZonePool* zone_pool, Graph* graph) {
   Schedule* schedule;
   bool had_floating_control = false;
   do {
-    Zone tmp_zone(graph->zone()->isolate());
+    ZonePool::Scope zone_scope(zone_pool);
     schedule = new (graph->zone())
         Schedule(graph->zone(), static_cast<size_t>(graph->NodeCount()));
-    Scheduler scheduler(&tmp_zone, graph, schedule);
+    Scheduler scheduler(zone_pool, zone_scope.zone(), graph, schedule);
 
     scheduler.BuildCFG();
-    Scheduler::ComputeSpecialRPO(schedule);
+    Scheduler::ComputeSpecialRPO(zone_pool, schedule);
     scheduler.GenerateImmediateDominatorTree();
 
     scheduler.PrepareUses();
     scheduler.ScheduleEarly();
     scheduler.ScheduleLate();
 
     had_floating_control = scheduler.ConnectFloatingControl();
   } while (had_floating_control);
 
   return schedule;
@@ skipping 603 matching lines @@
          i != schedule_root_nodes_.end(); ++i) {
       Trace("#%d:%s ", (*i)->id(), (*i)->op()->mnemonic());
     }
     Trace("\n");
   }
 
   // Schedule: Places nodes in dominator block of all their uses.
   ScheduleLateNodeVisitor schedule_late_visitor(this);
 
   {
-    Zone zone(zone_->isolate());
+    ZonePool::Scope zone_scope(zone_pool_);
+    Zone* zone = zone_scope.zone();
     GenericGraphVisit::Visit<ScheduleLateNodeVisitor,
                              NodeInputIterationTraits<Node> >(
-        graph_, &zone, schedule_root_nodes_.begin(), schedule_root_nodes_.end(),
+        graph_, zone, schedule_root_nodes_.begin(), schedule_root_nodes_.end(),
         &schedule_late_visitor);
   }
 
   // Add collected nodes for basic blocks to their blocks in the right order.
   int block_num = 0;
   for (NodeVectorVectorIter i = scheduled_nodes_.begin();
        i != scheduled_nodes_.end(); ++i) {
     for (NodeVectorRIter j = i->rbegin(); j != i->rend(); ++j) {
       schedule_->AddNode(schedule_->all_blocks_.at(block_num), *j);
     }
@@ skipping 303 matching lines @@
 // a RPO of the graph where loop bodies are contiguous. Properties:
 // 1. If block A is a predecessor of B, then A appears before B in the order,
 //    unless B is a loop header and A is in the loop headed at B
 //    (i.e. A -> B is a backedge).
 // => If block A dominates block B, then A appears before B in the order.
 // => If block A is a loop header, A appears before all blocks in the loop
 //    headed at A.
 // 2. All loops are contiguous in the order (i.e. no intervening blocks that
 //    do not belong to the loop.)
 // Note a simple RPO traversal satisfies (1) but not (3).
-BasicBlockVector* Scheduler::ComputeSpecialRPO(Schedule* schedule) {
-  Zone tmp_zone(schedule->zone()->isolate());
-  Zone* zone = &tmp_zone;
+BasicBlockVector* Scheduler::ComputeSpecialRPO(ZonePool* zone_pool,
+                                               Schedule* schedule) {
+  ZonePool::Scope zone_scope(zone_pool);
+  Zone* zone = zone_scope.zone();
   Trace("--- COMPUTING SPECIAL RPO ----------------------------------\n");
   // RPO should not have been computed for this schedule yet.
   CHECK_EQ(kBlockUnvisited1, schedule->start()->rpo_number());
   CHECK_EQ(0, static_cast<int>(schedule->rpo_order_.size()));
 
   // Perform an iterative RPO traversal using an explicit stack,
   // recording backedges that form cycles. O(|B|).
   ZoneList<std::pair<BasicBlock*, size_t> > backedges(1, zone);
   SpecialRPOStackFrame* stack = zone->NewArray<SpecialRPOStackFrame>(
       static_cast<int>(schedule->BasicBlockCount()));
@@ skipping 174 matching lines @@
 #if DEBUG
   if (FLAG_trace_turbo_scheduler) PrintRPO(num_loops, loops, final_order);
   VerifySpecialRPO(num_loops, loops, final_order);
 #endif
   return final_order;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8