Cleanup unscheduled use count for controls of coupled nodes.

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 104 matching lines @@
         UNREACHABLE();
         break;
       case IrOpcode::kPhi:
       case IrOpcode::kEffectPhi: {
         // Phis and effect phis are coupled to their respective blocks.
         DCHECK_EQ(Scheduler::kCoupled, data->placement_);
         DCHECK_EQ(Scheduler::kFixed, placement);
         Node* control = NodeProperties::GetControlInput(node);
         BasicBlock* block = schedule_->block(control);
         schedule_->AddNode(block, node);
-        // TODO(mstarzinger): Cheap hack to make sure unscheduled use count of
-        // control does not drop below zero. This might cause the control to be
-        // queued for scheduling more than once, which makes this ugly!
-        ++(GetData(control)->unscheduled_count_);
         break;
       }
 #define DEFINE_FLOATING_CONTROL_CASE(V) case IrOpcode::k##V:
       CONTROL_OP_LIST(DEFINE_FLOATING_CONTROL_CASE)
 #undef DEFINE_FLOATING_CONTROL_CASE
       {
         // Control nodes force coupled uses to be placed.
         Node::Uses uses = node->uses();
         for (Node::Uses::iterator i = uses.begin(); i != uses.end(); ++i) {
           if (GetPlacement(*i) == Scheduler::kCoupled) {
             DCHECK_EQ(node, NodeProperties::GetControlInput(*i));
             UpdatePlacement(*i, placement);
           }
         }
         break;
       }
       default:
         DCHECK_EQ(Scheduler::kSchedulable, data->placement_);
         DCHECK_EQ(Scheduler::kScheduled, placement);
         break;
     }
     // Reduce the use count of the node's inputs to potentially make them
     // schedulable. If all the uses of a node have been scheduled, then the node
     // itself can be scheduled.
     for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
       // TODO(mstarzinger): Another cheap hack for use counts.
       if (GetData(*i)->placement_ == kFixed) continue;
-      DecrementUnscheduledUseCount(*i, i.edge().from());
+      DecrementUnscheduledUseCount(*i, i.index(), i.edge().from());
     }
   }
   data->placement_ = placement;
 }
 
 
-void Scheduler::IncrementUnscheduledUseCount(Node* node, Node* from) {
+bool Scheduler::IsCoupledControlEdge(Node* node, int index) {
+  return GetPlacement(node) == kCoupled &&
+         NodeProperties::FirstControlIndex(node) == index;
+}
+
+
+void Scheduler::IncrementUnscheduledUseCount(Node* node, int index,
+                                             Node* from) {
+  // Make sure that control edges from coupled nodes are not counted.
+  if (IsCoupledControlEdge(from, index)) return;
+
+  // Use count for coupled nodes is summed up on their control.
   if (GetPlacement(node) == kCoupled) {
-    // Use count for coupled nodes is summed up on their control.
     Node* control = NodeProperties::GetControlInput(node);
-    return IncrementUnscheduledUseCount(control, from);
+    return IncrementUnscheduledUseCount(control, index, from);
   }
+
   ++(GetData(node)->unscheduled_count_);
   if (FLAG_trace_turbo_scheduler) {
     Trace("  Use count of #%d:%s (used by #%d:%s)++ = %d\n", node->id(),
           node->op()->mnemonic(), from->id(), from->op()->mnemonic(),
           GetData(node)->unscheduled_count_);
   }
 }
 
 
-void Scheduler::DecrementUnscheduledUseCount(Node* node, Node* from) {
+void Scheduler::DecrementUnscheduledUseCount(Node* node, int index,
+                                             Node* from) {
+  // Make sure that control edges from coupled nodes are not counted.
+  if (IsCoupledControlEdge(from, index)) return;
+
+  // Use count for coupled nodes is summed up on their control.
   if (GetPlacement(node) == kCoupled) {
-    // Use count for coupled nodes is summed up on their control.
     Node* control = NodeProperties::GetControlInput(node);
-    return DecrementUnscheduledUseCount(control, from);
+    return DecrementUnscheduledUseCount(control, index, from);
   }
+
   DCHECK(GetData(node)->unscheduled_count_ > 0);
   --(GetData(node)->unscheduled_count_);
   if (FLAG_trace_turbo_scheduler) {
     Trace("  Use count of #%d:%s (used by #%d:%s)-- = %d\n", node->id(),
           node->op()->mnemonic(), from->id(), from->op()->mnemonic(),
           GetData(node)->unscheduled_count_);
   }
   if (GetData(node)->unscheduled_count_ == 0) {
     Trace("    newly eligible #%d:%s\n", node->id(), node->op()->mnemonic());
     schedule_queue_.push(node);
@@ skipping 809 matching lines @@
         DCHECK(block != NULL);
         schedule_->AddNode(block, 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. Also make sure that control edges from coupled
-    // nodes are not counted. The same criterion will be used in ScheduleLate
+    // for all of its inputs. The same criterion will be used in ScheduleLate
     // for decrementing use counts.
-    if (!schedule_->IsScheduled(from) && !IsCoupledControlEdge(from, index)) {
+    if (!schedule_->IsScheduled(from)) {
       DCHECK_NE(Scheduler::kFixed, scheduler_->GetPlacement(from));
-      scheduler_->IncrementUnscheduledUseCount(to, from);
+      scheduler_->IncrementUnscheduledUseCount(to, index, from);
     }
   }
 
-  bool IsCoupledControlEdge(Node* node, int index) {
-    return scheduler_->GetPlacement(node) == Scheduler::kCoupled &&
-           NodeProperties::FirstControlIndex(node) == index;
-  }
-
  private:
   Scheduler* scheduler_;
   Schedule* schedule_;
 };
 
 
 void Scheduler::PrepareUses() {
   Trace("--- PREPARE USES -------------------------------------------\n");
 
   // Count the uses of every node, it will be used to ensure that all of a
@@ skipping 319 matching lines @@
   for (NodeVectorIter i = nodes->begin(); i != nodes->end(); ++i) {
     schedule_->SetBlockForNode(to, *i);
     scheduled_nodes_[to->id().ToSize()].push_back(*i);
   }
   nodes->clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8