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 9858 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;
+  }
+
+  if (info->payload()->IsJSArray()) {

[danno, 2013/01/10 22:58:59]

You might not need this additional checks yet if you avoid creating the
AllocationSiteInfos for non array types for now.

[mvstanton, 2013/01/11 13:43:01]

Ah, this if is a relic (or forebearer?) of the changes to follow, where we cased
on whether the payload was an array or a globalproperty object to distinguish
between the literal and constructor cases. I guess I can just assert the
condition here. Later, in fact it will change again to be an AllocationSite
object.

+    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());
@@ skipping 3352 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