Move some methods from OperatorProperties into Scheduler that are only related to scheduling. Now t…

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 "src/compiler/scheduler.h"
 
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
@@ skipping 35 matching lines @@
   scheduler.GenerateImmediateDominatorTree();
 
   scheduler.PrepareUses();
   scheduler.ScheduleEarly();
   scheduler.ScheduleLate();
 
   return schedule;
 }
 
 
+bool Scheduler::IsBasicBlockBegin(Node* node) {
+  return OperatorProperties::IsBasicBlockBegin(node->op());
+}
+
+
+bool Scheduler::CanBeScheduled(Node* node) { return true; }
+
+
+bool Scheduler::HasFixedSchedulePosition(Node* node) {
+  IrOpcode::Value opcode = node->opcode();
+  return (IrOpcode::IsControlOpcode(opcode)) ||
+         opcode == IrOpcode::kParameter || opcode == IrOpcode::kEffectPhi ||
+         opcode == IrOpcode::kPhi;
+}
+
+
+bool Scheduler::IsScheduleRoot(Node* node) {
+  IrOpcode::Value opcode = node->opcode();
+  return opcode == IrOpcode::kEnd || opcode == IrOpcode::kEffectPhi ||
+         opcode == IrOpcode::kPhi;
+}
+
+
 class CreateBlockVisitor : public NullNodeVisitor {
  public:
   explicit CreateBlockVisitor(Scheduler* scheduler) : scheduler_(scheduler) {}
 
   GenericGraphVisit::Control Post(Node* node) {
     Schedule* schedule = scheduler_->schedule_;
     switch (node->opcode()) {
       case IrOpcode::kIfTrue:
       case IrOpcode::kIfFalse:
       case IrOpcode::kContinuation:
@@ skipping 77 matching lines @@
 
 void Scheduler::AddPredecessorsForLoopsAndMerges() {
   for (NodeVectorIter i = loops_and_merges_.begin();
        i != loops_and_merges_.end(); ++i) {
     Node* merge_or_loop = *i;
     BasicBlock* block = schedule_->block(merge_or_loop);
     DCHECK(block != NULL);
     // For all of the merge's control inputs, add a goto at the end to the
     // merge's basic block.
     for (InputIter j = (*i)->inputs().begin(); j != (*i)->inputs().end(); ++j) {
-      if (OperatorProperties::IsBasicBlockBegin((*i)->op())) {
+      if (IsBasicBlockBegin((*i))) {
         BasicBlock* predecessor_block = schedule_->block(*j);
         if ((*j)->opcode() != IrOpcode::kReturn &&
             (*j)->opcode() != IrOpcode::kDeoptimize) {
           DCHECK(predecessor_block != NULL);
           if (FLAG_trace_turbo_scheduler) {
             IrOpcode::Value opcode = (*i)->opcode();
             PrintF("node %d (%s) in block %d -> block %d\n", (*i)->id(),
                    IrOpcode::Mnemonic(opcode), predecessor_block->id(),
                    block->id());
           }
@@ skipping 197 matching lines @@
       }
     }
     return GenericGraphVisit::CONTINUE;
   }
 
   GenericGraphVisit::Control Post(Node* node) {
     int id = node->id();
     int max_rpo = 0;
     // Otherwise, the minimum rpo for the node is the max of all of the inputs.
     if (!IsFixedNode(node)) {
-      DCHECK(!OperatorProperties::IsBasicBlockBegin(node->op()));
+      DCHECK(!scheduler_->IsBasicBlockBegin(node));
       for (InputIter i = node->inputs().begin(); i != node->inputs().end();
            ++i) {
         int control_rpo = scheduler_->schedule_early_rpo_index_[(*i)->id()];
         if (control_rpo > max_rpo) {
           max_rpo = control_rpo;
         }
       }
       if (scheduler_->schedule_early_rpo_index_[id] != max_rpo) {
         has_changed_rpo_constraints_ = true;
       }
       scheduler_->schedule_early_rpo_index_[id] = max_rpo;
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Node %d post-scheduled early at rpo limit %d\n", id, max_rpo);
       }
     }
     return GenericGraphVisit::CONTINUE;
   }
 
-  static bool IsFixedNode(Node* node) {
-    return OperatorProperties::HasFixedSchedulePosition(node->op()) ||
-           !OperatorProperties::CanBeScheduled(node->op());
+  bool IsFixedNode(Node* node) {
+    return scheduler_->HasFixedSchedulePosition(node) ||
+           !scheduler_->CanBeScheduled(node);
   }
 
   // TODO(mstarzinger): Dirty hack to unblock others, schedule early should be
   // rewritten to use a pre-order traversal from the start instead.
   bool has_changed_rpo_constraints_;
 
  private:
   Scheduler* scheduler_;
   Schedule* schedule_;
 };
@@ skipping 21 matching lines @@
 class PrepareUsesVisitor : public NullNodeVisitor {
  public:
   explicit PrepareUsesVisitor(Scheduler* scheduler)
       : scheduler_(scheduler), schedule_(scheduler->schedule_) {}
 
   GenericGraphVisit::Control Pre(Node* node) {
     // Some nodes must be scheduled explicitly to ensure they are in exactly the
     // right place; it's a convenient place during the preparation of use counts
     // to schedule them.
     if (!schedule_->IsScheduled(node) &&
-        OperatorProperties::HasFixedSchedulePosition(node->op())) {
+        scheduler_->HasFixedSchedulePosition(node)) {
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Fixed position node %d is unscheduled, scheduling now\n",
                node->id());
       }
       IrOpcode::Value opcode = node->opcode();
       BasicBlock* block =
           opcode == IrOpcode::kParameter
               ? schedule_->entry()
               : schedule_->block(NodeProperties::GetControlInput(node));
       DCHECK(block != NULL);
       schedule_->AddNode(block, node);
     }
 
-    if (OperatorProperties::IsScheduleRoot(node->op())) {
+    if (scheduler_->IsScheduleRoot(node)) {
       scheduler_->schedule_root_nodes_.push_back(node);
     }
 
     return GenericGraphVisit::CONTINUE;
   }
 
   void PostEdge(Node* from, int index, Node* to) {
     // If the edge is from an unscheduled node, then tally it in the use count
     // for all of its inputs. The same criterion will be used in ScheduleLate
     // for decrementing use counts.
-    if (!schedule_->IsScheduled(from) &&
-        OperatorProperties::CanBeScheduled(from->op())) {
-      DCHECK(!OperatorProperties::HasFixedSchedulePosition(from->op()));
+    if (!schedule_->IsScheduled(from) && scheduler_->CanBeScheduled(from)) {
+      DCHECK(!scheduler_->HasFixedSchedulePosition(from));
       ++scheduler_->unscheduled_uses_[to->id()];
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Incrementing uses of node %d from %d to %d\n", to->id(),
                from->id(), scheduler_->unscheduled_uses_[to->id()]);
       }
     }
   }
 
  private:
   Scheduler* scheduler_;
@@ skipping 12 matching lines @@
 }
 
 
 class ScheduleLateNodeVisitor : public NullNodeVisitor {
  public:
   explicit ScheduleLateNodeVisitor(Scheduler* scheduler)
       : scheduler_(scheduler), schedule_(scheduler_->schedule_) {}
 
   GenericGraphVisit::Control Pre(Node* node) {
     // Don't schedule nodes that cannot be scheduled or are already scheduled.
-    if (!OperatorProperties::CanBeScheduled(node->op()) ||
-        schedule_->IsScheduled(node)) {
+    if (!scheduler_->CanBeScheduled(node) || schedule_->IsScheduled(node)) {
       return GenericGraphVisit::CONTINUE;
     }
-    DCHECK(!OperatorProperties::HasFixedSchedulePosition(node->op()));
+    DCHECK(!scheduler_->HasFixedSchedulePosition(node));
 
     // If all the uses of a node have been scheduled, then the node itself can
     // be scheduled.
     bool eligible = scheduler_->unscheduled_uses_[node->id()] == 0;
     if (FLAG_trace_turbo_scheduler) {
       PrintF("Testing for schedule eligibility for node %d -> %s\n", node->id(),
              eligible ? "true" : "false");
     }
     if (!eligible) return GenericGraphVisit::DEFER;
 
@@ skipping 46 matching lines @@
 
     ScheduleNode(block, node);
 
     return GenericGraphVisit::CONTINUE;
   }
 
  private:
   BasicBlock* GetBlockForUse(Node::Edge edge) {
     Node* use = edge.from();
     IrOpcode::Value opcode = use->opcode();
-    // If the use is a phi, forward through the the phi to the basic block
+    // If the use is a phi, forward through the phi to the basic block
     // corresponding to the phi's input.
     if (opcode == IrOpcode::kPhi || opcode == IrOpcode::kEffectPhi) {
       int index = edge.index();
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Use %d is input %d to a phi\n", use->id(), index);
       }
       use = NodeProperties::GetControlInput(use, 0);
       opcode = use->opcode();
       DCHECK(opcode == IrOpcode::kMerge || opcode == IrOpcode::kLoop);
       use = NodeProperties::GetControlInput(use, index);
     }
     BasicBlock* result = schedule_->block(use);
     if (result == NULL) return NULL;
     if (FLAG_trace_turbo_scheduler) {
       PrintF("Must dominate use %d in block %d\n", use->id(), result->id());
     }
     return result;
   }
 
-  bool IsNodeEligible(Node* node) {
-    bool eligible = scheduler_->unscheduled_uses_[node->id()] == 0;
-    return eligible;
-  }
-
   void ScheduleNode(BasicBlock* block, Node* node) {
     schedule_->PlanNode(block, node);
     scheduler_->scheduled_nodes_[block->id()].push_back(node);
 
     // Reduce the use count of the node's inputs to potentially make them
     // scheduable.
     for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
       DCHECK(scheduler_->unscheduled_uses_[(*i)->id()] > 0);
       --scheduler_->unscheduled_uses_[(*i)->id()];
       if (FLAG_trace_turbo_scheduler) {
@@ skipping 440 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 v8::internal::compiler