Remove duplication in Scheduler and simplify interface. Make ComputeSchedule()...

Remove duplication in Scheduler and simplify interface. Make ComputeSchedule() and ComputeSpecialRPO() the only interface used by clients.

R=bmeurer@chromium.org
BUG=

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

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

src/compiler/pipeline.cc

@@ -222,9 +222,8 @@ Handle<Code> Pipeline::GenerateCode() {
 
 
 Schedule* Pipeline::ComputeSchedule(Graph* graph) {
-  Scheduler scheduler(zone());
   PhaseStats schedule_stats(info(), PhaseStats::CODEGEN, "scheduling");
-  return scheduler.NewSchedule(graph);
+  return Scheduler::ComputeSchedule(graph);
 }
 
 

src/compiler/raw-machine-assembler.cc

@@ -34,8 +34,7 @@ RawMachineAssembler::RawMachineAssembler(
 Schedule* RawMachineAssembler::Export() {
   // Compute the correct codegen order.
   DCHECK(schedule_->rpo_order()->empty());
-  Scheduler scheduler(zone(), graph(), schedule_);
-  scheduler.ComputeSpecialRPO();
+  Scheduler::ComputeSpecialRPO(schedule_);
   // Invalidate MachineAssembler.
   Schedule* schedule = schedule_;
   schedule_ = NULL;

src/compiler/scheduler.cc

@@ -15,22 +15,6 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
-Scheduler::Scheduler(Zone* zone)
-    : zone_(zone),
-      graph_(NULL),
-      schedule_(NULL),
-      branches_(NodeVector::allocator_type(zone)),
-      calls_(NodeVector::allocator_type(zone)),
-      deopts_(NodeVector::allocator_type(zone)),
-      returns_(NodeVector::allocator_type(zone)),
-      loops_and_merges_(NodeVector::allocator_type(zone)),
-      node_block_placement_(BasicBlockVector::allocator_type(zone)),
-      unscheduled_uses_(IntVector::allocator_type(zone)),
-      scheduled_nodes_(NodeVectorVector::allocator_type(zone)),
-      schedule_root_nodes_(NodeVector::allocator_type(zone)),
-      schedule_early_rpo_index_(IntVector::allocator_type(zone)) {}
-
-
 Scheduler::Scheduler(Zone* zone, Graph* graph, Schedule* schedule)
     : zone_(zone),
       graph_(graph),
@@ -47,30 +31,26 @@ Scheduler::Scheduler(Zone* zone, Graph* graph, Schedule* schedule)
       schedule_early_rpo_index_(IntVector::allocator_type(zone)) {}
 
 
-Schedule* Scheduler::NewSchedule(Graph* graph) {
-  graph_ = graph;
-  schedule_ = new (zone_) Schedule(zone_);
-
-  schedule_->AddNode(schedule_->end(), graph_->end());
-
-  PrepareAuxiliaryNodeData();
-
-  // Create basic blocks for each block and merge node in the graph.
-  CreateBlocks();
+Schedule* Scheduler::ComputeSchedule(Graph* graph) {
+  Zone tmp_zone(graph->zone()->isolate());
+  Schedule* schedule = new (graph->zone()) Schedule(graph->zone());
+  Scheduler scheduler(&tmp_zone, graph, schedule);
 
-  // Wire the basic blocks together.
-  WireBlocks();
+  schedule->AddNode(schedule->end(), graph->end());
 
-  PrepareAuxiliaryBlockData();
+  scheduler.PrepareAuxiliaryNodeData();
+  scheduler.CreateBlocks();
+  scheduler.WireBlocks();
+  scheduler.PrepareAuxiliaryBlockData();
 
-  ComputeSpecialRPO();
-  GenerateImmediateDominatorTree();
+  Scheduler::ComputeSpecialRPO(schedule);
+  scheduler.GenerateImmediateDominatorTree();
 
-  PrepareUses();
-  ScheduleEarly();
-  ScheduleLate();
+  scheduler.PrepareUses();
+  scheduler.ScheduleEarly();
+  scheduler.ScheduleLate();
 
-  return schedule_;
+  return schedule;
 }
 
 
@@ -866,20 +846,22 @@ static void VerifySpecialRPO(int num_loops, LoopInfo* loops,
 // 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() {
+BasicBlockVector* Scheduler::ComputeSpecialRPO(Schedule* schedule) {
+  Zone tmp_zone(schedule->zone()->isolate());
+  Zone* zone = &tmp_zone;
   if (FLAG_trace_turbo_scheduler) {
     PrintF("------------- COMPUTING SPECIAL RPO ---------------\n");
   }
   // RPO should not have been computed for this schedule yet.
-  CHECK_EQ(kBlockUnvisited1, schedule_->entry()->rpo_number_);
-  CHECK_EQ(0, static_cast<int>(schedule_->rpo_order_.size()));
+  CHECK_EQ(kBlockUnvisited1, schedule->entry()->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*, int> > backedges(1, zone_);
+  ZoneList<std::pair<BasicBlock*, int> > backedges(1, zone);
   SpecialRPOStackFrame* stack =
-      zone_->NewArray<SpecialRPOStackFrame>(schedule_->BasicBlockCount());
-  BasicBlock* entry = schedule_->entry();
+      zone->NewArray<SpecialRPOStackFrame>(schedule->BasicBlockCount());
+  BasicBlock* entry = schedule->entry();
   BlockList* order = NULL;
   int stack_depth = Push(stack, 0, entry, kBlockUnvisited1);
   int num_loops = 0;
@@ -895,7 +877,7 @@ BasicBlockVector* Scheduler::ComputeSpecialRPO() {
       if (succ->rpo_number_ == kBlockOnStack) {
         // The successor is on the stack, so this is a backedge (cycle).
         backedges.Add(
-            std::pair<BasicBlock*, int>(frame->block, frame->index - 1), zone_);
+            std::pair<BasicBlock*, int>(frame->block, frame->index - 1), zone);
         if (succ->loop_end_ < 0) {
           // Assign a new loop number to the header if it doesn't have one.
           succ->loop_end_ = num_loops++;
@@ -907,7 +889,7 @@ BasicBlockVector* Scheduler::ComputeSpecialRPO() {
       }
     } else {
       // Finished with all successors; pop the stack and add the block.
-      order = order->Add(zone_, frame->block);
+      order = order->Add(zone, frame->block);
       frame->block->rpo_number_ = kBlockVisited1;
       stack_depth--;
     }
@@ -918,8 +900,8 @@ BasicBlockVector* Scheduler::ComputeSpecialRPO() {
   if (num_loops != 0) {
     // Otherwise, compute the loop information from the backedges in order
     // to perform a traversal that groups loop bodies together.
-    loops = ComputeLoopInfo(zone_, stack, num_loops,
-                            schedule_->BasicBlockCount(), &backedges);
+    loops = ComputeLoopInfo(zone, stack, num_loops, schedule->BasicBlockCount(),
+                            &backedges);
 
     // Initialize the "loop stack". Note the entry could be a loop header.
     LoopInfo* loop = entry->IsLoopHeader() ? &loops[entry->loop_end_] : NULL;
@@ -944,7 +926,7 @@ BasicBlockVector* Scheduler::ComputeSpecialRPO() {
           // Finish the loop body the first time the header is left on the
           // stack.
           DCHECK(loop != NULL && loop->header == block);
-          loop->start = order->Add(zone_, block);
+          loop->start = order->Add(zone, block);
           order = loop->end;
           block->rpo_number_ = kBlockVisited2;
           // Pop the loop stack and continue visiting outgoing edges within the
@@ -973,7 +955,7 @@ BasicBlockVector* Scheduler::ComputeSpecialRPO() {
         if (loop != NULL && !loop->members->Contains(succ->id())) {
           // The successor is not in the current loop or any nested loop.
           // Add it to the outgoing edges of this loop and visit it later.
-          loop->AddOutgoing(zone_, succ);
+          loop->AddOutgoing(zone, succ);
         } else {
           // Push the successor onto the stack.
           stack_depth = Push(stack, stack_depth, succ, kBlockUnvisited2);
@@ -1001,7 +983,7 @@ BasicBlockVector* Scheduler::ComputeSpecialRPO() {
           order = info->start;
         } else {
           // Pop a single node off the stack and add it to the order.
-          order = order->Add(zone_, block);
+          order = order->Add(zone, block);
           block->rpo_number_ = kBlockVisited2;
         }
         stack_depth--;
@@ -1010,7 +992,7 @@ BasicBlockVector* Scheduler::ComputeSpecialRPO() {
   }
 
   // Construct the final order from the list.
-  BasicBlockVector* final_order = &schedule_->rpo_order_;
+  BasicBlockVector* final_order = &schedule->rpo_order_;
   order->Serialize(final_order);
 
   // Compute the correct loop header for every block and set the correct loop

src/compiler/scheduler.h

@@ -18,14 +18,15 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
+// Computes a schedule from a graph, placing nodes into basic blocks and
+// ordering the basic blocks in the special RPO order.
 class Scheduler {
  public:
-  explicit Scheduler(Zone* zone);
-  Scheduler(Zone* zone, Graph* graph, Schedule* schedule);
-
-  Schedule* NewSchedule(Graph* graph);
+  // Create a new schedule and place all computations from the graph in it.
+  static Schedule* ComputeSchedule(Graph* graph);
 
-  BasicBlockVector* ComputeSpecialRPO();
+  // Compute the RPO of blocks in an existing schedule.
+  static BasicBlockVector* ComputeSpecialRPO(Schedule* schedule);
 
  private:
   Zone* zone_;
@@ -42,6 +43,8 @@ class Scheduler {
   NodeVector schedule_root_nodes_;
   IntVector schedule_early_rpo_index_;
 
+  Scheduler(Zone* zone, Graph* graph, Schedule* schedule);
+
   int GetRPONumber(BasicBlock* block) {
     DCHECK(block->rpo_number_ >= 0 &&
            block->rpo_number_ < static_cast<int>(schedule_->rpo_order_.size()));

src/compiler/structured-machine-assembler.cc

@@ -41,8 +41,7 @@ StructuredMachineAssembler::StructuredMachineAssembler(
 Schedule* StructuredMachineAssembler::Export() {
   // Compute the correct codegen order.
   DCHECK(schedule_->rpo_order()->empty());
-  Scheduler scheduler(zone(), graph(), schedule_);
-  scheduler.ComputeSpecialRPO();
+  Scheduler::ComputeSpecialRPO(schedule_);
   // Invalidate MachineAssembler.
   Schedule* schedule = schedule_;
   schedule_ = NULL;

test/cctest/compiler/test-instruction.cc

@@ -51,8 +51,7 @@ class InstructionTester : public HandleAndZoneScope {
   void allocCode() {
     if (schedule.rpo_order()->size() == 0) {
       // Compute the RPO order.
-      Scheduler scheduler(zone(), &graph, &schedule);
-      scheduler.ComputeSpecialRPO();
+      Scheduler::ComputeSpecialRPO(&schedule);
       DCHECK(schedule.rpo_order()->size() > 0);
     }
     code = new TestInstrSeq(&linkage, &graph, &schedule);

test/cctest/compiler/test-scheduler.cc

@@ -68,9 +68,8 @@ static void CheckLoopContains(BasicBlock** blocks, int body_size) {
 TEST(RPODegenerate1) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 1, false);
   CHECK_EQ(schedule.entry(), order->at(0));
 }
@@ -79,10 +78,9 @@ TEST(RPODegenerate1) {
 TEST(RPODegenerate2) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   schedule.AddGoto(schedule.entry(), schedule.exit());
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 2, false);
   CHECK_EQ(schedule.entry(), order->at(0));
   CHECK_EQ(schedule.exit(), order->at(1));
@@ -94,7 +92,6 @@ TEST(RPOLine) {
 
   for (int i = 0; i < 10; i++) {
     Schedule schedule(scope.main_zone());
-    Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
     BasicBlock* last = schedule.entry();
     for (int j = 0; j < i; j++) {
@@ -102,7 +99,7 @@ TEST(RPOLine) {
       schedule.AddGoto(last, block);
       last = block;
     }
-    BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+    BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
     CheckRPONumbers(order, 1 + i, false);
 
     Schedule::BasicBlocks blocks(schedule.all_blocks());
@@ -120,9 +117,8 @@ TEST(RPOLine) {
 TEST(RPOSelfLoop) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
   schedule.AddSuccessor(schedule.entry(), schedule.entry());
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 1, true);
   BasicBlock* loop[] = {schedule.entry()};
   CheckLoopContains(loop, 1);
@@ -132,10 +128,9 @@ TEST(RPOSelfLoop) {
 TEST(RPOEntryLoop) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
   schedule.AddSuccessor(schedule.entry(), schedule.exit());
   schedule.AddSuccessor(schedule.exit(), schedule.entry());
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 2, true);
   BasicBlock* loop[] = {schedule.entry(), schedule.exit()};
   CheckLoopContains(loop, 2);
@@ -145,10 +140,9 @@ TEST(RPOEntryLoop) {
 TEST(RPOEndLoop) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2));
   schedule.AddSuccessor(schedule.entry(), loop1->header());
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 3, true);
   CheckLoopContains(loop1->nodes, loop1->count);
 }
@@ -157,11 +151,10 @@ TEST(RPOEndLoop) {
 TEST(RPOEndLoopNested) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2));
   schedule.AddSuccessor(schedule.entry(), loop1->header());
   schedule.AddSuccessor(loop1->last(), schedule.entry());
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 3, true);
   CheckLoopContains(loop1->nodes, loop1->count);
 }
@@ -170,7 +163,6 @@ TEST(RPOEndLoopNested) {
 TEST(RPODiamond) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   BasicBlock* A = schedule.entry();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -182,7 +174,7 @@ TEST(RPODiamond) {
   schedule.AddSuccessor(B, D);
   schedule.AddSuccessor(C, D);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 4, false);
 
   CHECK_EQ(0, A->rpo_number_);
@@ -195,7 +187,6 @@ TEST(RPODiamond) {
 TEST(RPOLoop1) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   BasicBlock* A = schedule.entry();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -207,7 +198,7 @@ TEST(RPOLoop1) {
   schedule.AddSuccessor(C, B);
   schedule.AddSuccessor(C, D);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 4, true);
   BasicBlock* loop[] = {B, C};
   CheckLoopContains(loop, 2);
@@ -217,7 +208,6 @@ TEST(RPOLoop1) {
 TEST(RPOLoop2) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   BasicBlock* A = schedule.entry();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -229,7 +219,7 @@ TEST(RPOLoop2) {
   schedule.AddSuccessor(C, B);
   schedule.AddSuccessor(B, D);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 4, true);
   BasicBlock* loop[] = {B, C};
   CheckLoopContains(loop, 2);
@@ -241,7 +231,6 @@ TEST(RPOLoopN) {
 
   for (int i = 0; i < 11; i++) {
     Schedule schedule(scope.main_zone());
-    Scheduler scheduler(scope.main_zone(), NULL, &schedule);
     BasicBlock* A = schedule.entry();
     BasicBlock* B = schedule.NewBasicBlock();
     BasicBlock* C = schedule.NewBasicBlock();
@@ -272,7 +261,7 @@ TEST(RPOLoopN) {
     if (i == 9) schedule.AddSuccessor(E, G);
     if (i == 10) schedule.AddSuccessor(F, G);
 
-    BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+    BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
     CheckRPONumbers(order, 7, true);
     BasicBlock* loop[] = {B, C, D, E, F};
     CheckLoopContains(loop, 5);
@@ -283,7 +272,6 @@ TEST(RPOLoopN) {
 TEST(RPOLoopNest1) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   BasicBlock* A = schedule.entry();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -300,7 +288,7 @@ TEST(RPOLoopNest1) {
   schedule.AddSuccessor(E, B);
   schedule.AddSuccessor(E, F);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 6, true);
   BasicBlock* loop1[] = {B, C, D, E};
   CheckLoopContains(loop1, 4);
@@ -313,7 +301,6 @@ TEST(RPOLoopNest1) {
 TEST(RPOLoopNest2) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   BasicBlock* A = schedule.entry();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -336,7 +323,7 @@ TEST(RPOLoopNest2) {
   schedule.AddSuccessor(F, C);
   schedule.AddSuccessor(G, B);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 8, true);
   BasicBlock* loop1[] = {B, C, D, E, F, G};
   CheckLoopContains(loop1, 6);
@@ -352,7 +339,6 @@ TEST(RPOLoopNest2) {
 TEST(RPOLoopFollow1) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1));
   SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1));
@@ -364,7 +350,7 @@ TEST(RPOLoopFollow1) {
   schedule.AddSuccessor(loop1->header(), loop2->header());
   schedule.AddSuccessor(loop2->last(), E);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
 
   CheckLoopContains(loop1->nodes, loop1->count);
 
@@ -377,7 +363,6 @@ TEST(RPOLoopFollow1) {
 TEST(RPOLoopFollow2) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1));
   SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1));
@@ -391,7 +376,7 @@ TEST(RPOLoopFollow2) {
   schedule.AddSuccessor(S, loop2->header());
   schedule.AddSuccessor(loop2->last(), E);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
 
   CheckLoopContains(loop1->nodes, loop1->count);
 
@@ -407,7 +392,6 @@ TEST(RPOLoopFollowN) {
   for (int size = 1; size < 5; size++) {
     for (int exit = 0; exit < size; exit++) {
       Schedule schedule(scope.main_zone());
-      Scheduler scheduler(scope.main_zone(), NULL, &schedule);
       SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
       SmartPointer<TestLoop> loop2(CreateLoop(&schedule, size));
       BasicBlock* A = schedule.entry();
@@ -416,7 +400,7 @@ TEST(RPOLoopFollowN) {
       schedule.AddSuccessor(A, loop1->header());
       schedule.AddSuccessor(loop1->nodes[exit], loop2->header());
       schedule.AddSuccessor(loop2->nodes[exit], E);
-      BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+      BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
       CheckLoopContains(loop1->nodes, loop1->count);
 
       CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
@@ -430,7 +414,6 @@ TEST(RPOLoopFollowN) {
 TEST(RPONestedLoopFollow1) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1));
   SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1));
@@ -447,7 +430,7 @@ TEST(RPONestedLoopFollow1) {
   schedule.AddSuccessor(C, E);
   schedule.AddSuccessor(C, B);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
 
   CheckLoopContains(loop1->nodes, loop1->count);
 
@@ -467,7 +450,6 @@ TEST(RPOLoopBackedges1) {
   for (int i = 0; i < size; i++) {
     for (int j = 0; j < size; j++) {
       Schedule schedule(scope.main_zone());
-      Scheduler scheduler(scope.main_zone(), NULL, &schedule);
       BasicBlock* A = schedule.entry();
       BasicBlock* E = schedule.exit();
 
@@ -478,7 +460,7 @@ TEST(RPOLoopBackedges1) {
       schedule.AddSuccessor(loop1->nodes[i], loop1->header());
       schedule.AddSuccessor(loop1->nodes[j], E);
 
-      BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+      BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
       CheckRPONumbers(order, schedule.BasicBlockCount(), true);
       CheckLoopContains(loop1->nodes, loop1->count);
     }
@@ -493,7 +475,6 @@ TEST(RPOLoopOutedges1) {
   for (int i = 0; i < size; i++) {
     for (int j = 0; j < size; j++) {
       Schedule schedule(scope.main_zone());
-      Scheduler scheduler(scope.main_zone(), NULL, &schedule);
       BasicBlock* A = schedule.entry();
       BasicBlock* D = schedule.NewBasicBlock();
       BasicBlock* E = schedule.exit();
@@ -506,7 +487,7 @@ TEST(RPOLoopOutedges1) {
       schedule.AddSuccessor(loop1->nodes[j], D);
       schedule.AddSuccessor(D, E);
 
-      BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+      BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
       CheckRPONumbers(order, schedule.BasicBlockCount(), true);
       CheckLoopContains(loop1->nodes, loop1->count);
     }
@@ -520,7 +501,6 @@ TEST(RPOLoopOutedges2) {
   int size = 8;
   for (int i = 0; i < size; i++) {
     Schedule schedule(scope.main_zone());
-    Scheduler scheduler(scope.main_zone(), NULL, &schedule);
     BasicBlock* A = schedule.entry();
     BasicBlock* E = schedule.exit();
 
@@ -534,7 +514,7 @@ TEST(RPOLoopOutedges2) {
       schedule.AddSuccessor(O, E);
     }
 
-    BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+    BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
     CheckRPONumbers(order, schedule.BasicBlockCount(), true);
     CheckLoopContains(loop1->nodes, loop1->count);
   }
@@ -547,7 +527,6 @@ TEST(RPOLoopOutloops1) {
   int size = 8;
   for (int i = 0; i < size; i++) {
     Schedule schedule(scope.main_zone());
-    Scheduler scheduler(scope.main_zone(), NULL, &schedule);
     BasicBlock* A = schedule.entry();
     BasicBlock* E = schedule.exit();
     SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
@@ -561,7 +540,7 @@ TEST(RPOLoopOutloops1) {
       schedule.AddSuccessor(loopN[j]->last(), E);
     }
 
-    BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+    BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
     CheckRPONumbers(order, schedule.BasicBlockCount(), true);
     CheckLoopContains(loop1->nodes, loop1->count);
 
@@ -577,7 +556,6 @@ TEST(RPOLoopOutloops1) {
 TEST(RPOLoopMultibackedge) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
-  Scheduler scheduler(scope.main_zone(), NULL, &schedule);
 
   BasicBlock* A = schedule.entry();
   BasicBlock* B = schedule.NewBasicBlock();
@@ -593,7 +571,7 @@ TEST(RPOLoopMultibackedge) {
   schedule.AddSuccessor(D, B);
   schedule.AddSuccessor(E, B);
 
-  BasicBlockVector* order = scheduler.ComputeSpecialRPO();
+  BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 5, true);
 
   BasicBlock* loop1[] = {B, C, D, E};
@@ -608,8 +586,7 @@ TEST(BuildScheduleEmpty) {
   graph.SetStart(graph.NewNode(builder.Start(0)));
   graph.SetEnd(graph.NewNode(builder.End(), graph.start()));
 
-  Scheduler scheduler(scope.main_zone());
-  USE(scheduler.NewSchedule(&graph));
+  USE(Scheduler::ComputeSchedule(&graph));
 }
 
 
@@ -624,8 +601,7 @@ TEST(BuildScheduleOneParameter) {
 
   graph.SetEnd(graph.NewNode(builder.End(), ret));
 
-  Scheduler scheduler(scope.main_zone());
-  USE(scheduler.NewSchedule(&graph));
+  USE(Scheduler::ComputeSchedule(&graph));
 }
 
 
@@ -684,8 +660,7 @@ TEST(BuildScheduleIfSplit) {
 
   PrintGraph(&graph);
 
-  Scheduler scheduler(scope.main_zone());
-  Schedule* schedule = scheduler.NewSchedule(&graph);
+  Schedule* schedule = Scheduler::ComputeSchedule(&graph);
 
   PrintSchedule(schedule);
 
@@ -838,8 +813,7 @@ TEST(BuildScheduleIfSplitWithEffects) {
 
   PrintGraph(&graph);
 
-  Scheduler scheduler(scope.main_zone());
-  Schedule* schedule = scheduler.NewSchedule(&graph);
+  Schedule* schedule = Scheduler::ComputeSchedule(&graph);
 
   PrintSchedule(schedule);
 
@@ -958,8 +932,7 @@ TEST(BuildScheduleSimpleLoop) {
 
   PrintGraph(&graph);
 
-  Scheduler scheduler(scope.main_zone());
-  Schedule* schedule = scheduler.NewSchedule(&graph);
+  Schedule* schedule = Scheduler::ComputeSchedule(&graph);
 
   PrintSchedule(schedule);
 
@@ -1213,8 +1186,7 @@ TEST(BuildScheduleComplexLoops) {
 
   PrintGraph(&graph);
 
-  Scheduler scheduler(scope.main_zone());
-  Schedule* schedule = scheduler.NewSchedule(&graph);
+  Schedule* schedule = Scheduler::ComputeSchedule(&graph);
 
   PrintSchedule(schedule);
 
@@ -1550,8 +1522,7 @@ TEST(BuildScheduleBreakAndContinue) {
 
   PrintGraph(&graph);
 
-  Scheduler scheduler(scope.main_zone());
-  Schedule* schedule = scheduler.NewSchedule(&graph);
+  Schedule* schedule = Scheduler::ComputeSchedule(&graph);
 
   PrintSchedule(schedule);
 
@@ -1682,8 +1653,7 @@ TEST(BuildScheduleSimpleLoopWithCodeMotion) {
 
   PrintGraph(&graph);
 
-  Scheduler scheduler(scope.main_zone());
-  Schedule* schedule = scheduler.NewSchedule(&graph);
+  Schedule* schedule = Scheduler::ComputeSchedule(&graph);
 
   PrintSchedule(schedule);
 
@@ -1803,8 +1773,7 @@ TEST(BuildScheduleTrivialLazyDeoptCall) {
 
   PrintGraph(&graph);
 
-  Scheduler scheduler(scope.main_zone());
-  Schedule* schedule = scheduler.NewSchedule(&graph);
+  Schedule* schedule = Scheduler::ComputeSchedule(&graph);
 
   PrintSchedule(schedule);