Supporting AllocationSiteInfo for Nested arrays

src/hydrogen.cc

 // Copyright 2012 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 5664 matching lines @@
   return false;
 }
 
 
 // Determines whether the given array or object literal boilerplate satisfies
 // all limits to be considered for fast deep-copying and computes the total
 // size of all objects that are part of the graph.
 static bool IsFastLiteral(Handle<JSObject> boilerplate,
                           int max_depth,
                           int* max_properties,
-                          int* total_size) {
+                          int* total_size,
+                          int* allocation_sites_count,
+                          AllocationSiteMode mode) {
   ASSERT(max_depth >= 0 && *max_properties >= 0);
   if (max_depth == 0) return false;
 
   Isolate* isolate = boilerplate->GetIsolate();
+  if (mode == TRACK_ALLOCATION_SITE &&
+      boilerplate->ShouldTrackAllocationInfo()) {
+    *total_size += AllocationSiteInfo::kSize;
+    *allocation_sites_count = *allocation_sites_count + 1;
+  }
+
   Handle<FixedArrayBase> elements(boilerplate->elements());
   if (elements->length() > 0 &&
       elements->map() != isolate->heap()->fixed_cow_array_map()) {
     if (boilerplate->HasFastDoubleElements()) {
       *total_size += FixedDoubleArray::SizeFor(elements->length());
     } else if (boilerplate->HasFastObjectElements()) {
       Handle<FixedArray> fast_elements = Handle<FixedArray>::cast(elements);
       int length = elements->length();
       for (int i = 0; i < length; i++) {
         if ((*max_properties)-- == 0) return false;
         Handle<Object> value(fast_elements->get(i), isolate);
         if (value->IsJSObject()) {
           Handle<JSObject> value_object = Handle<JSObject>::cast(value);
           if (!IsFastLiteral(value_object,
                              max_depth - 1,
                              max_properties,
-                             total_size)) {
+                             total_size,
+                             allocation_sites_count,
+                             mode)) {
             return false;
           }
         }
       }
       *total_size += FixedArray::SizeFor(length);
     } else {
       return false;
     }
   }
 
   Handle<FixedArray> properties(boilerplate->properties());
   if (properties->length() > 0) {
     return false;
   } else {
     int nof = boilerplate->map()->inobject_properties();
     for (int i = 0; i < nof; i++) {
       if ((*max_properties)-- == 0) return false;
       Handle<Object> value(boilerplate->InObjectPropertyAt(i), isolate);
       if (value->IsJSObject()) {
         Handle<JSObject> value_object = Handle<JSObject>::cast(value);
         if (!IsFastLiteral(value_object,
                            max_depth - 1,
                            max_properties,
-                           total_size)) {
+                           total_size,
+                           allocation_sites_count,
+                           mode)) {
           return false;
         }
       }
     }
   }
 
   *total_size += boilerplate->map()->instance_size();
   return true;
 }
 
 
 void HOptimizedGraphBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   Handle<JSFunction> closure = function_state()->compilation_info()->closure();
   HValue* context = environment()->LookupContext();
   HInstruction* literal;
 
+  // We don't want to use AllocationSiteInfo when the object literal is
+  // declared at global scope without a surrounding loop, that means it's
+  // literal arrays will never be re-created, and therefore don't benefit from
+  // site info.
+  AllocationSiteMode mode = FLAG_track_allocation_sites && !IsOneTimeCode()
+      ? TRACK_ALLOCATION_SITE
+      : DONT_TRACK_ALLOCATION_SITE;
+
   // Check whether to use fast or slow deep-copying for boilerplate.
   int total_size = 0;
+  int allocation_sites_count = 0;
   int max_properties = HFastLiteral::kMaxLiteralProperties;
-  Handle<Object> boilerplate(closure->literals()->get(expr->literal_index()),
-                             isolate());
-  if (boilerplate->IsJSObject() &&
-      IsFastLiteral(Handle<JSObject>::cast(boilerplate),
+  Handle<Object> original_boilerplate(closure->literals()->get(
+      expr->literal_index()), isolate());
+  if (original_boilerplate->IsJSObject() &&
+      IsFastLiteral(Handle<JSObject>::cast(original_boilerplate),
                     HFastLiteral::kMaxLiteralDepth,
                     &max_properties,
-                    &total_size)) {
-    Handle<JSObject> boilerplate_object = Handle<JSObject>::cast(boilerplate);
+                    &total_size,
+                    &allocation_sites_count,
+                    mode)) {
+    // Copy the boilerplate to prevent unsavory sharing between fullcodegen and
+    // crankshaft.
+    Handle<JSObject> original_boilerplate_object =
+        Handle<JSObject>::cast(original_boilerplate);
+    Handle<JSObject> boilerplate = DeepCopy(original_boilerplate_object);
+    int size_without_allocation_sites = total_size -
+        allocation_sites_count * AllocationSiteInfo::kSize;
     literal = new(zone()) HFastLiteral(context,
-                                       boilerplate_object,
+                                       boilerplate,
+                                       original_boilerplate_object,
                                        total_size,
                                        expr->literal_index(),
                                        expr->depth(),
-                                       DONT_TRACK_ALLOCATION_SITE);
+                                       mode,
+                                       size_without_allocation_sites);
   } else {
     literal = new(zone()) HObjectLiteral(context,
                                          expr->constant_properties(),
                                          expr->fast_elements(),
                                          expr->literal_index(),
                                          expr->depth(),
-                                         expr->has_function());
+                                         expr->has_function(),
+                                         mode);
   }
 
   // The object is expected in the bailout environment during computation
   // of the property values and is the value of the entire expression.
   PushAndAdd(literal);
 
   expr->CalculateEmitStore(zone());
 
   for (int i = 0; i < expr->properties()->length(); i++) {
     ObjectLiteral::Property* property = expr->properties()->at(i);
@@ skipping 64 matching lines @@
 
 void HOptimizedGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   ZoneList<Expression*>* subexprs = expr->values();
   int length = subexprs->length();
   HValue* context = environment()->LookupContext();
   HInstruction* literal;
 
+  AllocationSiteMode mode = FLAG_track_allocation_sites && !IsOneTimeCode()
+      ? TRACK_ALLOCATION_SITE
+      : DONT_TRACK_ALLOCATION_SITE;
+
   Handle<FixedArray> literals(environment()->closure()->literals());
   Handle<Object> raw_boilerplate(literals->get(expr->literal_index()),
                                  isolate());
-
   if (raw_boilerplate->IsUndefined()) {
     raw_boilerplate = Runtime::CreateArrayLiteralBoilerplate(
         isolate(), literals, expr->constant_elements());
     if (raw_boilerplate.is_null()) {
       return Bailout("array boilerplate creation failed");
     }
     literals->set(expr->literal_index(), *raw_boilerplate);
     if (JSObject::cast(*raw_boilerplate)->elements()->map() ==
         isolate()->heap()->fixed_cow_array_map()) {
       isolate()->counters()->cow_arrays_created_runtime()->Increment();
     }
   }
 
-  Handle<JSObject> boilerplate = Handle<JSObject>::cast(raw_boilerplate);
+  Handle<JSObject> original_boilerplate =
+      Handle<JSObject>::cast(raw_boilerplate);
   ElementsKind boilerplate_elements_kind =
-      Handle<JSObject>::cast(boilerplate)->GetElementsKind();
-
-  // TODO(mvstanton): This heuristic is only a temporary solution.  In the
-  // end, we want to quit creating allocation site info after a certain number
-  // of GCs for a call site.
-  AllocationSiteMode mode = AllocationSiteInfo::GetMode(
-      boilerplate_elements_kind);
+      original_boilerplate->GetElementsKind();
 
   // Check whether to use fast or slow deep-copying for boilerplate.
   int total_size = 0;
+  int allocation_sites_count = 0;
   int max_properties = HFastLiteral::kMaxLiteralProperties;
-  if (IsFastLiteral(boilerplate,
+  if (IsFastLiteral(original_boilerplate,
                     HFastLiteral::kMaxLiteralDepth,
                     &max_properties,
-                    &total_size)) {
-    if (mode == TRACK_ALLOCATION_SITE) {
-      total_size += AllocationSiteInfo::kSize;
-    }
+                    &total_size,
+                    &allocation_sites_count,
+                    mode)) {
+    // Copy the boilerplate to prevent unsavory sharing between fullcodegen and
+    // crankshaft.
+    int size_without_allocation_sites = total_size -
+        allocation_sites_count * AllocationSiteInfo::kSize;
+    Handle<JSObject> boilerplate = DeepCopy(original_boilerplate);
     literal = new(zone()) HFastLiteral(context,
                                        boilerplate,
+                                       original_boilerplate,
                                        total_size,
                                        expr->literal_index(),
                                        expr->depth(),
-                                       mode);
+                                       mode,
+                                       size_without_allocation_sites);
   } else {
     literal = new(zone()) HArrayLiteral(context,
-                                        boilerplate,
+                                        original_boilerplate,
                                         length,
                                         expr->literal_index(),
                                         expr->depth(),
                                         mode);
   }
 
   // The array is expected in the bailout environment during computation
   // of the property values and is the value of the entire expression.
   PushAndAdd(literal);
 
@@ skipping 5035 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal