Give uses within a loop a greater weight when doing representation inference.

src/hydrogen-instructions.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 49 matching lines @@
     case kDouble: return "d";
     case kInteger32: return "i";
     case kExternal: return "x";
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
+template<class T> inline const T& min(const T& a, const T& b) {
+  return (a < b) ? a : b;
+}
+
+
+int HValue::LoopWeight() const {
+  const int w = FLAG_loop_weight;
+  static const int weights[] = { 1, w, w*w, w*w*w, w*w*w*w };

[fschneider, 2012/01/27 22:33:24]

I think no need for static here. Actually, I'd also be fine with hard-coding the
weight to 10 here, so that the compiler can inline the constants. Once set, we
probably don't need to change it often.

[Sven Panne, 2012/01/30 07:51:04]

Well, initializing the array every time wouldn't be very cool, either, so I went
for a 'static' (What I really wanted to write is 'iterate (*w) 1' ;-).  But
you're right, when we figured out a sensible weight, we should probably change
this to a simple switch on block()->LoopNestingDepth() and use a real constant.

+  return weights[min(block()->LoopNestingDepth(),
+                     static_cast<int>(ARRAY_SIZE(weights)-1))];
+}
+
+
 void HValue::AssumeRepresentation(Representation r) {
   if (CheckFlag(kFlexibleRepresentation)) {
     ChangeRepresentation(r);
     // The representation of the value is dictated by type feedback and
     // will not be changed later.
     ClearFlag(kFlexibleRepresentation);
   }
 }
 
 
@@ skipping 1030 matching lines @@
 }
 
 
 void HPhi::InitRealUses(int phi_id) {
   // Initialize real uses.
   phi_id_ = phi_id;
   for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
     HValue* value = it.value();
     if (!value->IsPhi()) {
       Representation rep = value->RequiredInputRepresentation(it.index());
-      ++non_phi_uses_[rep.kind()];
+      non_phi_uses_[rep.kind()] += value->LoopWeight();
     }
   }
 }
 
 
 void HPhi::AddNonPhiUsesFrom(HPhi* other) {
   for (int i = 0; i < Representation::kNumRepresentations; i++) {
     indirect_uses_[i] += other->non_phi_uses_[i];
   }
 }
@@ skipping 835 matching lines @@
 
 
 void HCheckPrototypeMaps::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal