Additional work to get array literal allocation tracking working, even with --always-opt

src/objects.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 7490 matching lines @@
         AllocationSiteInfo* info = AllocationSiteInfo::cast(
             reinterpret_cast<Object*>(ptr_end + 1));
         return info;
       }
     }
   }
   return NULL;
 }
 
 
+// Heuristic: We only need to create allocation site info if the boilerplate
+// elements kind is the initial elements kind.
+AllocationSiteMode AllocationSiteInfo::GetMode(
+    ElementsKind boilerplate_elements_kind) {
+  if (FLAG_track_allocation_sites &&
+      IsFastSmiElementsKind(boilerplate_elements_kind)) {
+    return TRACK_ALLOCATION_SITE;
+  }
+
+  return DONT_TRACK_ALLOCATION_SITE;
+}
+
+
+AllocationSiteMode AllocationSiteInfo::GetMode(ElementsKind from,
+                                               ElementsKind to) {
+  if (FLAG_track_allocation_sites &&
+      IsFastSmiElementsKind(from) &&
+      (IsFastObjectElementsKind(to) || IsFastDoubleElementsKind(to))) {
+    return TRACK_ALLOCATION_SITE;
+  }
+
+  return DONT_TRACK_ALLOCATION_SITE;
+}
+
+
 uint32_t StringHasher::MakeArrayIndexHash(uint32_t value, int length) {
   // For array indexes mix the length into the hash as an array index could
   // be zero.
   ASSERT(length > 0);
   ASSERT(length <= String::kMaxArrayIndexSize);
   ASSERT(TenToThe(String::kMaxCachedArrayIndexLength) <
          (1 << String::kArrayIndexValueBits));
 
   value <<= String::kHashShift;
   value |= length << String::kArrayIndexHashLengthShift;
@@ skipping 2347 matching lines @@
     FixedDoubleArray::cast(elements())->set(index, value->Number());
     ValidateElements();
     return value;
   }
   // Change elements kind from Smi-only to generic FAST if necessary.
   if (HasFastSmiElements() && !value->IsSmi()) {
     Map* new_map;
     ElementsKind kind = HasFastHoleyElements()
         ? FAST_HOLEY_ELEMENTS
         : FAST_ELEMENTS;
+
+    MaybeObject* trans = PossiblyTransitionArrayBoilerplate(kind);
+    if (trans->IsFailure()) return trans;
+
     MaybeObject* maybe_new_map = GetElementsTransitionMap(GetIsolate(),
                                                           kind);
     if (!maybe_new_map->To(&new_map)) return maybe_new_map;
 
     set_map(new_map);
   }
   // Increase backing store capacity if that's been decided previously.
   if (new_capacity != capacity) {
     FixedArray* new_elements;
     SetFastElementsCapacitySmiMode smi_mode =
@@ skipping 511 matching lines @@
                                                 ElementsKind to_kind) {
   CALL_HEAP_FUNCTION(object->GetIsolate(),
                      object->TransitionElementsKind(to_kind),
                      Object);
 }
 
 
 MaybeObject* JSObject::PossiblyTransitionArrayBoilerplate(
     ElementsKind to_kind) {
   MaybeObject* ret = NULL;
-  if (IsJSArray()) {
-    AllocationSiteInfo* info = AllocationSiteInfo::FindForJSObject(this);
-    if (info != NULL) {
-      JSObject* payload = JSObject::cast(info->payload());
-      if (payload->GetElementsKind() != to_kind) {
-        if (IsMoreGeneralElementsKindTransition(payload->GetElementsKind(),
-                                                to_kind)) {
-          ret = payload->TransitionElementsKind(to_kind);
-        }
+  if (!FLAG_track_allocation_sites || !IsJSArray()) {
+    return ret;
+  }
+
+  AllocationSiteInfo* info = AllocationSiteInfo::FindForJSObject(this);
+  if (info == NULL) {
+    return ret;
+  }
+
+  ASSERT(info->payload()->IsJSArray());
+  JSArray* payload = JSArray::cast(info->payload());
+  ElementsKind kind = payload->GetElementsKind();
+  if (IsMoreGeneralElementsKindTransition(kind, to_kind)) {
+    // If the array is huge, it's not likely to be defined in a local
+    // function, so we shouldn't make new instances of it very often.
+    uint32_t length = 0;
+    CHECK(payload->length()->ToArrayIndex(&length));
+    if (length <= 8 * 1024) {
+      ret = payload->TransitionElementsKind(to_kind);
+      if (FLAG_trace_track_allocation_sites) {
+        PrintF(
+            "AllocationSiteInfo: JSArray %p boilerplate updated %s->%s\n",
+            reinterpret_cast<void*>(this),
+            ElementsKindToString(kind),
+            ElementsKindToString(to_kind));
       }
     }
   }
   return ret;
 }
 
 
 MaybeObject* JSObject::TransitionElementsKind(ElementsKind to_kind) {
   ASSERT(!map()->is_observed());
   ElementsKind from_kind = map()->elements_kind();
@@ skipping 3351 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal