[turbofan] Improve some heuristics in escape analysis

src/compiler/escape-analysis.cc

 // Copyright 2015 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/escape-analysis.h"
 
 #include <limits>
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
@@ skipping 76 matching lines @@
     phi_[offset] = created_phi;
   }
   bool IsTracked() const { return status_ & kTracked; }
   bool IsInitialized() const { return status_ & kInitialized; }
   bool SetInitialized() { return status_ |= kInitialized; }
   VirtualState* owner() const { return owner_; }
 
   Node** fields_array() { return &fields_.front(); }
   size_t field_count() { return fields_.size(); }
   bool ResizeFields(size_t field_count) {
-    if (field_count != fields_.size()) {
+    if (field_count > fields_.size()) {
       fields_.resize(field_count);
       phi_.resize(field_count);
       return true;
     }
     return false;
   }
   void ClearAllFields() {
     for (size_t i = 0; i < fields_.size(); ++i) {
       fields_[i] = nullptr;
       phi_[i] = false;
@@ skipping 643 matching lines @@
     }
   }
 }
 
 EscapeAnalysis::EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common,
                                Zone* zone)
     : status_analysis_(this, graph, zone),
       common_(common),
       virtual_states_(zone),
       replacements_(zone),
-      cache_(new (zone) MergeCache(zone)) {}
+      cache_(nullptr) {}
 
 EscapeAnalysis::~EscapeAnalysis() {}
 
 void EscapeAnalysis::Run() {
   replacements_.resize(graph()->NodeCount());
   status_analysis_.AssignAliases();
-  if (status_analysis_.AliasCount() == 0) return;
-  status_analysis_.ResizeStatusVector();
-  RunObjectAnalysis();
-  status_analysis_.RunStatusAnalysis();
+  if (status_analysis_.AliasCount() > 0) {
+    cache_ = new (zone()) MergeCache(zone());
+    replacements_.resize(graph()->NodeCount());
+    status_analysis_.ResizeStatusVector();
+    RunObjectAnalysis();
+    status_analysis_.RunStatusAnalysis();
+  }
 }
 
 void EscapeStatusAnalysis::AssignAliases() {
-  stack_.reserve(graph()->NodeCount() * 0.2);
+  size_t max_size = 1024;
+  size_t min_size = 32;
+  size_t stack_size = std::min(
+      std::max(
+          std::min(graph()->NodeCount() / 5, graph()->NodeCount() / 20 + 128),
+          min_size),
+      max_size);
+  stack_.reserve(stack_size);
   ResizeStatusVector();
   stack_.push_back(graph()->end());
   CHECK_LT(graph()->NodeCount(), kUntrackable);
   aliases_.resize(graph()->NodeCount(), kNotReachable);
   aliases_[graph()->end()->id()] = kUntrackable;
   status_stack_.reserve(8);
   TRACE("Discovering trackable nodes");
   while (!stack_.empty()) {
     Node* node = stack_.back();
     stack_.pop_back();
@@ skipping 15 matching lines @@
               stack_.push_back(allocate);
             }
             aliases_[allocate->id()] = NextAlias();
             TRACE(" @%d:%s#%u", aliases_[allocate->id()],
                   allocate->op()->mnemonic(), allocate->id());
             EnqueueForStatusAnalysis(allocate);
           }
           aliases_[node->id()] = aliases_[allocate->id()];
           TRACE(" @%d:%s#%u", aliases_[node->id()], node->op()->mnemonic(),
                 node->id());
-
-        } else {
-          aliases_[node->id()] = NextAlias();
-          TRACE(" @%d:%s#%u", aliases_[node->id()], node->op()->mnemonic(),
-                node->id());
         }
         break;
       }
       default:
         DCHECK_EQ(aliases_[node->id()], kUntrackable);
         break;
     }
     for (Edge edge : node->input_edges()) {
       Node* input = edge.to();
       if (aliases_[input->id()] == kNotReachable) {
@@ skipping 159 matching lines @@
       continue;
     switch (node->opcode()) {
       case IrOpcode::kStoreField:
       case IrOpcode::kLoadField:
       case IrOpcode::kStoreElement:
       case IrOpcode::kLoadElement:
       case IrOpcode::kFrameState:
       case IrOpcode::kStateValues:
       case IrOpcode::kReferenceEqual:
       case IrOpcode::kFinishRegion:
-      case IrOpcode::kPhi:
+      case IrOpcode::kObjectIsSmi:
         break;
       default:
         VirtualState* state = virtual_states_[node->id()];
         if (VirtualObject* obj = ResolveVirtualObject(state, input)) {
           if (!obj->AllFieldsClear()) {
             obj = CopyForModificationAt(obj, state, node);
             obj->ClearAllFields();
             TRACE("Cleared all fields of @%d:#%d\n", GetAlias(obj->id()),
                   obj->id());
           }
@@ skipping 518 matching lines @@
         return true;
       }
     }
   }
   return false;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8