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

src/heap.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 4344 matching lines @@
   global->set_map(new_map);
   global->set_properties(dictionary);
 
   // Make sure result is a global object with properties in dictionary.
   ASSERT(global->IsGlobalObject());
   ASSERT(!global->HasFastProperties());
   return global;
 }
 
 
-MaybeObject* Heap::CopyJSObject(JSObject* source) {
+MaybeObject* Heap::CopyJSObject(JSObject* source,
+                                AllocationSiteInfoMode mode) {
   // Never used to copy functions.  If functions need to be copied we
   // have to be careful to clear the literals array.
   SLOW_ASSERT(!source->IsJSFunction());
 
   // Make the clone.
   Map* map = source->map();
   int object_size = map->instance_size();
   Object* clone;
 
+  bool track_origin = FLAG_track_allocation_sites &&
+      mode == TRACK_ALLOCATION_SITE_INFO;
+
   WriteBarrierMode wb_mode = UPDATE_WRITE_BARRIER;
 
   // If we're forced to always allocate, we use the general allocation
   // functions which may leave us with an object in old space.
   if (always_allocate()) {
     { MaybeObject* maybe_clone =
           AllocateRaw(object_size, NEW_SPACE, OLD_POINTER_SPACE);
       if (!maybe_clone->ToObject(&clone)) return maybe_clone;
     }
     Address clone_address = HeapObject::cast(clone)->address();
     CopyBlock(clone_address,
               source->address(),
               object_size);
     // Update write barrier for all fields that lie beyond the header.
     RecordWrites(clone_address,
                  JSObject::kHeaderSize,
                  (object_size - JSObject::kHeaderSize) / kPointerSize);
+
+    // Track allocation site information
+    if (track_origin && InNewSpace(clone)) {

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

This is a bit dicey. Although I don't see a reason that the two allocations (the
object above and the AllocationSiteInfo) won't be contiguous, it's a bit
fragile. If track_origin is false, you should call AllocateRaw as before. If
it's true, you should check object_size against:

  Heap* heap = isolate()->heap();
  const int kMinFreeNewSpaceAfterGC = heap->InitialSemiSpaceSize() * 3/4;

and if it's smaller, call AllocateInNewSpace for both objects together, it
_must_ succeed in this case. In the case that object_size is greater than
kMinFreeNewSpaceAfterGC, don't allocate the AllocationSiteInfo at all. 

Also note that in this code you are allocation AllocationSiteInfos for all
objects you allocate, not just JSArrays. Maybe you want add a predicate
CanTrackAllocationSite to Map that returns "true" for JSArray maps, and then
change the track_origin predicate above to contain "&&
source->map()->CanTrackAllocationSite() 

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

Thanks, good advice. I actually removed the FLAG_track_allocation_sites, as it
seems to be everywhere. I figure that if someone has asked for the feature to be
on as a parameter to the function call, like here, then any flag checking is
upstream.

+      MaybeObject* maybe_alloc_info =
+          AllocateStruct(ALLOCATION_SITE_INFO_TYPE);
+      AllocationSiteInfo* alloc_info;
+      if (maybe_alloc_info->To(&alloc_info)) {
+        alloc_info->set_map(allocation_site_info_map());
+        alloc_info->set_payload(source);
+      }
+    }
   } else {
     wb_mode = SKIP_WRITE_BARRIER;
-    { MaybeObject* maybe_clone = new_space_.AllocateRaw(object_size);
+
+    int adjusted_object_size = object_size;
+    if (track_origin) {
+      adjusted_object_size += AllocationSiteInfo::kSize;
+    }
+
+    { MaybeObject* maybe_clone = new_space_.AllocateRaw(adjusted_object_size);
       if (!maybe_clone->ToObject(&clone)) return maybe_clone;
     }
     SLOW_ASSERT(InNewSpace(clone));
     // Since we know the clone is allocated in new space, we can copy
     // the contents without worrying about updating the write barrier.
     CopyBlock(HeapObject::cast(clone)->address(),
               source->address(),
               object_size);
+
+    if (track_origin) {
+      AllocationSiteInfo* alloc_info = reinterpret_cast<AllocationSiteInfo*>(
+          reinterpret_cast<Address>(clone) + object_size);
+      alloc_info->set_map(allocation_site_info_map());
+      // TODO(mvstanton): I don't understand this payload? the original object?

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

Yes. And as discussed today, this is a bit wrong right now, it kind of assumes
that source is a boilerplate array because this code path gated by track_origin
is only used to copy boilerplate arrays (see my code above to limit tracking to
just JSArrays).

When you copy deep boilerplates, you will have to pass in the AllocationSite to
use rather than the array itself.

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

Right. For the moment, the boilerplate is exactly the right payload. Later, when
we move to AllocationMomentos, it will live in the AllocationSite object
instead. For this checkin I just remove the TODO.

+      alloc_info->set_payload(source);
+    }
   }
 
   SLOW_ASSERT(
       JSObject::cast(clone)->GetElementsKind() == source->GetElementsKind());
   FixedArrayBase* elements = FixedArrayBase::cast(source->elements());
   FixedArray* properties = FixedArray::cast(source->properties());
   // Update elements if necessary.
   if (elements->length() > 0) {
     Object* elem;
     { MaybeObject* maybe_elem;
@@ skipping 2943 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   memcpy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   memcpy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal