Basic array capacity feedback via allocation sites.

src/hydrogen.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 "src/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 2499 matching lines @@
 
 HValue* HGraphBuilder::BuildAllocateArrayFromLength(
     JSArrayBuilder* array_builder,
     HValue* length_argument) {
   if (length_argument->IsConstant() &&
       HConstant::cast(length_argument)->HasSmiValue()) {
     int array_length = HConstant::cast(length_argument)->Integer32Value();
     if (array_length == 0) {
       return array_builder->AllocateEmptyArray();
     } else {
-      return array_builder->AllocateArray(length_argument,
-                                          array_length,
+      // If we have capacity feedback, we want the capacity to be
+      // max(array_length, feedback).
+      HValue* capacity_value = length_argument;
+      HValue* site_value = array_builder->allocation_site();
+      if (site_value != NULL && site_value->IsConstant()) {
+        Handle<AllocationSite> site = Handle<AllocationSite>::cast(
+            HConstant::cast(site_value)->handle(isolate()));
+        int capacity_feedback = site->GetInitialElementsCapacity();
+        if (capacity_feedback > array_length) {
+          if (FLAG_trace_track_allocation_sites) {
+            PrintF("site %p, capacity adjusted from %d to %d\n",
+                   static_cast<void*>(*site), array_length,
+                   capacity_feedback);
+          }
+          array_length = capacity_feedback;
+          capacity_value = Add<HConstant>(capacity_feedback);
+        }
+      }
+      return array_builder->AllocateArray(capacity_value, array_length,
                                           length_argument);
     }
   }
 
   HValue* constant_zero = graph()->GetConstant0();
   HConstant* max_alloc_length =
       Add<HConstant>(JSObject::kInitialMaxFastElementArray);
   HInstruction* checked_length = Add<HBoundsCheck>(length_argument,
                                                    max_alloc_length);
   IfBuilder if_builder(this);
   if_builder.If<HCompareNumericAndBranch>(checked_length, constant_zero,
                                           Token::EQ);
   if_builder.Then();
-  const int initial_capacity = JSArray::kPreallocatedArrayElements;
-  HConstant* initial_capacity_node = Add<HConstant>(initial_capacity);
-  Push(initial_capacity_node);  // capacity
+  Push(constant_zero);          // capacity
   Push(constant_zero);          // length
   if_builder.Else();
   if (!(top_info()->IsStub()) &&
       IsFastPackedElementsKind(array_builder->kind())) {
     // We'll come back later with better (holey) feedback.
     if_builder.Deopt("Holey array despite packed elements_kind feedback");
   } else {
     Push(checked_length);         // capacity
     Push(checked_length);         // length
   }
@@ skipping 217 matching lines @@
 void HGraphBuilder::BuildFillElementsWithValue(HValue* elements,
                                                ElementsKind elements_kind,
                                                HValue* from,
                                                HValue* to,
                                                HValue* value) {
   if (to == NULL) {
     to = AddLoadFixedArrayLength(elements);
   }
 
   // Special loop unfolding case
-  STATIC_ASSERT(JSArray::kPreallocatedArrayElements <=
-                kElementLoopUnrollThreshold);
+  DCHECK(JSArray::PreallocatedArrayElements() <= kElementLoopUnrollThreshold);
   int initial_capacity = -1;
   if (from->IsInteger32Constant() && to->IsInteger32Constant()) {
     int constant_from = from->GetInteger32Constant();
     int constant_to = to->GetInteger32Constant();
 
     if (constant_from == 0 && constant_to <= kElementLoopUnrollThreshold) {
       initial_capacity = constant_to;
     }
   }
 
@@ skipping 431 matching lines @@
 
 
 HValue* HGraphBuilder::JSArrayBuilder::EmitInternalMapCode() {
   // Find the map near the constructor function
   HObjectAccess access = HObjectAccess::ForPrototypeOrInitialMap();
   return builder()->Add<HLoadNamedField>(
       constructor_function_, static_cast<HValue*>(NULL), access);
 }
 
 
+HConstant* HGraphBuilder::JSArrayBuilder::initial_capacity() {
+  int capacity = 0;
+  if (allocation_site_payload_ != NULL) {
+    if (allocation_site_payload_->IsConstant()) {
+      Handle<AllocationSite> site =
+          Handle<AllocationSite>::cast(HConstant::cast(allocation_site_payload_)
+                                           ->handle(builder()->isolate()));
+      int possible_capacity = site->GetInitialElementsCapacity();
+      if (possible_capacity > 0) {
+        capacity = possible_capacity;
+        if (FLAG_trace_track_allocation_sites) {
+          PrintF("site %p, feedback adjusted to %d\n",
+                 static_cast<void*>(*site), possible_capacity);
+        }
+      }
+    }
+  }
+  return HConstant::New(zone(), builder()->context(), capacity);
+}
+
+
 HAllocate* HGraphBuilder::JSArrayBuilder::AllocateEmptyArray() {
-  HConstant* capacity = builder()->Add<HConstant>(initial_capacity());
+  HConstant* capacity = initial_capacity();
+  builder()->AddInstruction(capacity);
   return AllocateArray(capacity,
                        capacity,
                        builder()->graph()->GetConstant0());
 }
 
 
 HAllocate* HGraphBuilder::JSArrayBuilder::AllocateArray(
     HValue* capacity,
     HConstant* capacity_upper_bound,
     HValue* length_field,
@@ skipping 9293 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal