Supporting AllocationSiteInfo for Nested arrays

src/objects-inl.h

 // 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 1443 matching lines @@
   MaybeObject* maybe = GetElementsTransitionMap(GetIsolate(), elements_kind);
   Map* map;
   if (!maybe->To(&map)) return maybe;
   set_map(map);
   initialize_elements();
 
   return this;
 }
 
 
+bool JSObject::ShouldTrackAllocationInfo() {

[danno, 2013/02/11 15:05:21]

How abound adding:

if (!IsJSArray()) return true;

This centralizes the policy for tracking on all objects to this function,
hopefully obviating the need for the extra IsJSArray check at the caller sites
(please update those, too).

[mvstanton, 2013/02/15 07:36:43]

Done.

+  if (map()->CanTrackAllocationSite()) {
+    return true;
+  }
+  return false;
+}
+
 MaybeObject* JSObject::AddFastPropertyUsingMap(Map* map) {
   ASSERT(this->map()->NumberOfOwnDescriptors() + 1 ==
          map->NumberOfOwnDescriptors());
   if (this->map()->unused_property_fields() == 0) {
     int new_size = properties()->length() + map->unused_property_fields() + 1;
     FixedArray* new_properties;
     MaybeObject* maybe_properties = properties()->CopySize(new_size);
     if (!maybe_properties->To(&new_properties)) return maybe_properties;
     set_properties(new_properties);
   }
@@ skipping 4144 matching lines @@
     // It's a performance benefit to keep a frequently used array in new-space.
   } else if (!GetHeap()->new_space()->Contains(elts) &&
              required_size < kArraySizeThatFitsComfortablyInNewSpace) {
     // Expand will allocate a new backing store in new space even if the size
     // we asked for isn't larger than what we had before.
     Expand(required_size);
   }
 }
 
 
+bool JSArray::ShouldTrackAllocationInfo() {

[danno, 2013/02/11 15:05:21]

I'm a little confused how JSArray::ShouldTrackAllocationInfo differs from
JSObject::ShouldTrackAllocation info. If possible, I think JSObject's version
should "do it all", i.e. even casting to JSArray and check the GetMode result on
GetElementsKind(). The idea is that there is a single method on JSObject that
returns whether the SiteAllocationInfo should be allocated without doing any
additional checks on the object's instance type.

[mvstanton, 2013/02/15 07:36:43]

I was thinking in terms of virtual overrides, where some object might bring
other factors into the decision. In the case of JSArray, it's a check on
ElementsKind...for other objects maybe it would be something different. I'll
consolidate this under JSObject, thx.

+  ASSERT(map()->CanTrackAllocationSite());
+  AllocationSiteMode mode = AllocationSiteInfo::GetMode(GetElementsKind());
+  return mode == TRACK_ALLOCATION_SITE;
+}
+
+
 void JSArray::set_length(Smi* length) {
   // Don't need a write barrier for a Smi.
   set_length(static_cast<Object*>(length), SKIP_WRITE_BARRIER);
 }
 
 
 bool JSArray::AllowsSetElementsLength() {
   bool result = elements()->IsFixedArray() || elements()->IsFixedDoubleArray();
   ASSERT(result == !HasExternalArrayElements());
   return result;
@@ skipping 252 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_