Minor cleanup about unscheduled use count for fixed 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 129 matching lines @@
       }
       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.index(), i.edge().from());
     }
   }
   data->placement_ = placement;
 }
 
 
 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;
 
+  // Tracking use counts for fixed nodes is useless.
+  if (GetPlacement(node) == kFixed) return;
+
   // Use count for coupled nodes is summed up on their control.
   if (GetPlacement(node) == kCoupled) {
     Node* control = NodeProperties::GetControlInput(node);
     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, int index,
                                              Node* from) {
   // Make sure that control edges from coupled nodes are not counted.
   if (IsCoupledControlEdge(from, index)) return;
 
+  // Tracking use counts for fixed nodes is useless.
+  if (GetPlacement(node) == kFixed) return;
+
   // Use count for coupled nodes is summed up on their control.
   if (GetPlacement(node) == kCoupled) {
     Node* control = NodeProperties::GetControlInput(node);
     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(),
@@ skipping 807 matching lines @@
  public:
   explicit PrepareUsesVisitor(Scheduler* scheduler)
       : scheduler_(scheduler), schedule_(scheduler->schedule_) {}
 
   GenericGraphVisit::Control Pre(Node* node) {
     if (scheduler_->GetPlacement(node) == Scheduler::kFixed) {
       // Fixed nodes are always roots for schedule late.
       scheduler_->schedule_root_nodes_.push_back(node);
       if (!schedule_->IsScheduled(node)) {
         // Make sure root nodes are scheduled in their respective blocks.
-        Trace("  Scheduling fixed position node #%d:%s\n", node->id(),
+        Trace("Scheduling fixed position node #%d:%s\n", node->id(),
               node->op()->mnemonic());
         IrOpcode::Value opcode = node->opcode();
         BasicBlock* block =
             opcode == IrOpcode::kParameter
                 ? schedule_->start()
                 : schedule_->block(NodeProperties::GetControlInput(node));
         DCHECK(block != NULL);
         schedule_->AddNode(block, node);
       }
     }
@@ skipping 343 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