[turbofan] Tune the ValueNumberingReducer's growth rate

src/compiler/value-numbering-reducer.cc

 // Copyright 2014 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/value-numbering-reducer.h"
 
 #include <cstring>
 
 #include "src/base/functional.h"
 #include "src/compiler/node-properties.h"
@@ skipping 51 matching lines @@
     // Allocate the initial entries and insert the first entry.
     capacity_ = kInitialCapacity;
     entries_ = temp_zone()->NewArray<Node*>(kInitialCapacity);
     memset(entries_, 0, sizeof(*entries_) * kInitialCapacity);
     entries_[hash & (kInitialCapacity - 1)] = node;
     size_ = 1;
     return NoChange();
   }
 
   DCHECK(size_ < capacity_);
-  DCHECK(size_ * kCapacityToSizeRatio < capacity_);
+  DCHECK(size_ + size_ / 4 < capacity_);
 
   const size_t mask = capacity_ - 1;
   size_t dead = capacity_;
 
   for (size_t i = hash & mask;; i = (i + 1) & mask) {
     Node* entry = entries_[i];
     if (!entry) {
       if (dead != capacity_) {
         // Reuse dead entry that we discovered on the way.
         entries_[dead] = node;
       } else {
         // Have to insert a new entry.
         entries_[i] = node;
         size_++;
 
-        // Resize to keep load factor below 1/kCapacityToSizeRatio.
-        if (size_ * kCapacityToSizeRatio >= capacity_) Grow();
+        // Resize to keep load factor below 80%
+        if (size_ + size_ / 4 >= capacity_) Grow();
       }
-      DCHECK(size_ * kCapacityToSizeRatio < capacity_);
+      DCHECK(size_ + size_ / 4 < capacity_);
       return NoChange();
     }
 
     if (entry == node) {
       // We need to check for a certain class of collisions here. Imagine the
       // following scenario:
       //
       //  1. We insert node1 with op1 and certain inputs at index i.
       //  2. We insert node2 with op2 and certain inputs at index i+1.
       //  3. Some other reducer changes node1 to op2 and the inputs from node2.
@@ skipping 43 matching lines @@
           }
         }
       }
       return Replace(entry);
     }
   }
 }
 
 
 void ValueNumberingReducer::Grow() {
-  // Allocate a new block of entries kCapacityToSizeRatio times the previous
-  // capacity.
+  // Allocate a new block of entries double the previous capacity.
   Node** const old_entries = entries_;
   size_t const old_capacity = capacity_;
-  capacity_ *= kCapacityToSizeRatio;
+  capacity_ *= 2;
   entries_ = temp_zone()->NewArray<Node*>(capacity_);
   memset(entries_, 0, sizeof(*entries_) * capacity_);
   size_ = 0;
   size_t const mask = capacity_ - 1;
 
   // Insert the old entries into the new block (skipping dead nodes).
   for (size_t i = 0; i < old_capacity; ++i) {
     Node* const old_entry = old_entries[i];
     if (!old_entry || old_entry->IsDead()) continue;
     for (size_t j = HashCode(old_entry) & mask;; j = (j + 1) & mask) {
       Node* const entry = entries_[j];
       if (entry == old_entry) {
         // Skip duplicate of the old entry.
         break;
       }
       if (!entry) {
         entries_[j] = old_entry;
         size_++;
         break;
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8