Allocation Info Tracking, continued.

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 3908 matching lines @@
   { MaybeObject* maybe_result =
         AllocateRaw(map->instance_size(), space, retry_space);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
   // No need for write barrier since object is white and map is in old space.
   HeapObject::cast(result)->set_map_no_write_barrier(map);
   return result;
 }
 
 
+// TODO(mvstanton): consolidate this with the function above.
+MaybeObject* Heap::AllocateWithAllocationSiteInfo(Map* map,
+    AllocationSpace space,
+    Handle<Object>* allocation_site_info_payload) {
+  ASSERT(gc_state_ == NOT_IN_GC);
+  ASSERT(map->instance_type() != MAP_TYPE);
+  // If allocation failures are disallowed, we may allocate in a different
+  // space when new space is full and the object is not a large object.
+  AllocationSpace retry_space =
+      (space != NEW_SPACE) ? space : TargetSpaceId(map->instance_type());
+  Object* result;
+  { MaybeObject* maybe_result =

[Toon Verwaest, 2013/02/13 15:14:51]

Remove {...}

[mvstanton, 2013/02/19 11:04:08]

Done, and I consolidated this function with the one above as my todo requested..

+        AllocateRaw(map->instance_size() + AllocationSiteInfo::kSize,
+                    space,
+                    retry_space);
+    if (!maybe_result->ToObject(&result)) return maybe_result;

[Toon Verwaest, 2013/02/13 15:14:51]

->To(&

+  }
+  // No need for write barrier since object is white and map is in old space.
+  HeapObject::cast(result)->set_map_no_write_barrier(map);
+  Object* allocation_pointer = reinterpret_cast<Object*>(
+      reinterpret_cast<Address>(result) + map->instance_size());
+  HeapObject::cast(allocation_pointer)->set_map_no_write_barrier(
+      allocation_site_info_map());
+  AllocationSiteInfo* allocation_site_info =
+      AllocationSiteInfo::cast(allocation_pointer);
+  allocation_site_info->set_payload(**allocation_site_info_payload);
+  return result;
+}
+
+
 void Heap::InitializeFunction(JSFunction* function,
                               SharedFunctionInfo* shared,
                               Object* prototype) {
   ASSERT(!prototype->IsMap());
   function->initialize_properties();
   function->initialize_elements();
   function->set_shared(shared);
   function->set_code(shared->code());
   function->set_prototype_or_initial_map(prototype);
   function->set_context(undefined_value());
@@ skipping 215 matching lines @@
     // We might want to shrink the object later.
     ASSERT(obj->GetInternalFieldCount() == 0);
     filler = Heap::one_pointer_filler_map();
   } else {
     filler = Heap::undefined_value();
   }
   obj->InitializeBody(map, Heap::undefined_value(), filler);
 }
 
 
-MaybeObject* Heap::AllocateJSObjectFromMap(Map* map, PretenureFlag pretenure) {
+MaybeObject* Heap::AllocateJSObjectFromMap(Map* map, PretenureFlag pretenure,
+    AllocationSiteMode mode,
+    Handle<Object>* allocation_site_info_payload) {
+  ASSERT(pretenure == NOT_TENURED || mode == DONT_TRACK_ALLOCATION_SITE);
   // JSFunctions should be allocated using AllocateFunction to be
   // properly initialized.
   ASSERT(map->instance_type() != JS_FUNCTION_TYPE);
 
   // Both types of global objects should be allocated using
   // AllocateGlobalObject to be properly initialized.
   ASSERT(map->instance_type() != JS_GLOBAL_OBJECT_TYPE);
   ASSERT(map->instance_type() != JS_BUILTINS_OBJECT_TYPE);
 
   // Allocate the backing storage for the properties.
   int prop_size =
       map->pre_allocated_property_fields() +
       map->unused_property_fields() -
       map->inobject_properties();
   ASSERT(prop_size >= 0);
   Object* properties;
   { MaybeObject* maybe_properties = AllocateFixedArray(prop_size, pretenure);
     if (!maybe_properties->ToObject(&properties)) return maybe_properties;
   }
 
   // Allocate the JSObject.
   AllocationSpace space =
       (pretenure == TENURED) ? OLD_POINTER_SPACE : NEW_SPACE;
   if (map->instance_size() > Page::kMaxNonCodeHeapObjectSize) space = LO_SPACE;
   Object* obj;
-  { MaybeObject* maybe_obj = Allocate(map, space);
+  {

[Toon Verwaest, 2013/02/13 15:14:51]

Remove {. ->To(&.

[mvstanton, 2013/02/19 11:04:08]

Done.

[mvstanton, 2013/02/19 11:04:08]

Done.

+    MaybeObject* maybe_obj;
+    if (mode == TRACK_ALLOCATION_SITE) {
+      maybe_obj = AllocateWithAllocationSiteInfo(map, space,
+                                                 allocation_site_info_payload);
+    } else {
+      maybe_obj = Allocate(map, space);
+    }
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
   }
 
   // Initialize the JSObject.
   InitializeJSObjectFromMap(JSObject::cast(obj),
                             FixedArray::cast(properties),
                             map);
   ASSERT(JSObject::cast(obj)->HasFastElements());
   return obj;
 }
 
 
 MaybeObject* Heap::AllocateJSObject(JSFunction* constructor,
-                                    PretenureFlag pretenure) {
+    PretenureFlag pretenure,
+    AllocationSiteMode mode,
+    Handle<Object>* allocation_site_info_payload) {
   // Allocate the initial map if absent.
   if (!constructor->has_initial_map()) {
     Object* initial_map;
     { MaybeObject* maybe_initial_map = AllocateInitialMap(constructor);
       if (!maybe_initial_map->ToObject(&initial_map)) return maybe_initial_map;
     }
     constructor->set_initial_map(Map::cast(initial_map));
     Map::cast(initial_map)->set_constructor(constructor);
   }
-  // Allocate the object based on the constructors initial map.
+  // Allocate the object based on the constructors initial map, or the payload
+  // advice
+  Map* initial_map = constructor->initial_map();
+  if (mode == TRACK_ALLOCATION_SITE) {
+    ASSERT(allocation_site_info_payload != NULL);
+    ASSERT((*allocation_site_info_payload)->IsJSGlobalPropertyCell());

[Toon Verwaest, 2013/02/13 15:14:51]

The cast below will take care of this assert.

[mvstanton, 2013/02/19 11:04:08]

Done.

+    JSGlobalPropertyCell* cell = JSGlobalPropertyCell::cast(
+        **allocation_site_info_payload);
+    ASSERT(cell->value()->IsSmi());

[Toon Verwaest, 2013/02/13 15:14:51]

The cast below will take care of this assert.

[mvstanton, 2013/02/19 11:04:08]

Done.

+    Smi* smi = Smi::cast(cell->value());
+    ElementsKind to_kind = static_cast<ElementsKind>(smi->value());
+    if (to_kind != initial_map->elements_kind()) {
+      initial_map = initial_map->LookupElementsTransitionMap(to_kind);
+      // TODO(mvstanton): I may have to allocate this transition, right?
+      ASSERT(initial_map != NULL);

[Toon Verwaest, 2013/02/13 15:14:51]

Yeah, it seems like you should ensure that the map is created if it isn't there
yet. Otherwise we'll end up with NULL-pointers as maps...

[mvstanton, 2013/02/19 11:04:08]

Done.

+      // constructor->set_initial_map(Map::cast(initial_map));

[Toon Verwaest, 2013/02/13 15:14:51]

omit Map::cast.

[mvstanton, 2013/02/19 11:04:08]

Done.

+      // Map::cast(initial_map)->set_constructor(constructor);
+      mode = DONT_TRACK_ALLOCATION_SITE;

[Toon Verwaest, 2013/02/13 15:14:51]

Weird;... you do all this work to set up the initial state; but then you abort
and set the mode to DONT_TRACK?

[mvstanton, 2013/02/19 11:04:08]

The code is trying to express that the advice was consumed at this point, and
there is no need to allocate tracking information in the object now. It's
probably cleaner to leave that up to the caller to do, so I can cut this section
down.

+    }
+  }
+
   MaybeObject* result = AllocateJSObjectFromMap(
-      constructor->initial_map(), pretenure);
+      initial_map, pretenure,
+      mode, allocation_site_info_payload);
 #ifdef DEBUG
   // Make sure result is NOT a global object if valid.
   Object* non_failure;
   ASSERT(!result->ToObject(&non_failure) || !non_failure->IsGlobalObject());
 #endif
   return result;
 }
 
 
 MaybeObject* Heap::AllocateJSModule(Context* context, ScopeInfo* scope_info) {
   // Allocate a fresh map. Modules do not have a prototype.
   Map* map;
   MaybeObject* maybe_map = AllocateMap(JS_MODULE_TYPE, JSModule::kSize);
   if (!maybe_map->To(&map)) return maybe_map;
   // Allocate the object based on the map.
   JSModule* module;
   MaybeObject* maybe_module = AllocateJSObjectFromMap(map, TENURED);
   if (!maybe_module->To(&module)) return maybe_module;
   module->set_context(context);
   module->set_scope_info(scope_info);
   return module;
 }
 
 
 MaybeObject* Heap::AllocateJSArrayAndStorage(
     ElementsKind elements_kind,
     int length,
     int capacity,
+    AllocationSiteMode allocation_site_info_mode,
+    Handle<Object> *allocation_site_payload,
     ArrayStorageAllocationMode mode,
     PretenureFlag pretenure) {
   ASSERT(capacity >= length);
-  MaybeObject* maybe_array = AllocateJSArray(elements_kind, pretenure);
+  ASSERT(allocation_site_payload != NULL ||
+         allocation_site_info_mode == DONT_TRACK_ALLOCATION_SITE);
+  if (pretenure == TENURED &&
+      allocation_site_info_mode == TRACK_ALLOCATION_SITE) {
+    PrintF("Sorry, can't track yet in tenured space\n");

[Toon Verwaest, 2013/02/13 15:14:51]

Euhm... Shouldn't we overwrite allocation_site_info_mode or so?

[mvstanton, 2013/02/19 11:04:08]

I changed this to an assert that if you want pre-tenuring you can't also have
allocation tracking. That may be stronger than necessary, but I'd rather weaken
the conditions later if needed (by ignoring the request to track allocation
info).

+  }
+  MaybeObject* maybe_array = AllocateJSArray(elements_kind, pretenure,
+                                             allocation_site_info_mode,
+                                             allocation_site_payload);
   JSArray* array;
   if (!maybe_array->To(&array)) return maybe_array;
 
   if (capacity == 0) {
     array->set_length(Smi::FromInt(0));
     array->set_elements(empty_fixed_array());
     return array;
   }
 
   FixedArrayBase* elms;
@@ skipping 158 matching lines @@
   // 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 = mode == TRACK_ALLOCATION_SITE &&
       map->CanTrackAllocationSite();
-
   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.
   int adjusted_object_size = object_size;
   if (always_allocate()) {
     // We'll only track origin if we are certain to allocate in new space
     if (track_origin) {
       const int kMinFreeNewSpaceAfterGC = InitialSemiSpaceSize() * 3/4;
       if ((object_size + AllocationSiteInfo::kSize) < kMinFreeNewSpaceAfterGC) {
         adjusted_object_size += AllocationSiteInfo::kSize;
       }
     }
 
     { MaybeObject* maybe_clone =
           AllocateRaw(adjusted_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)) {
+      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;
+
     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());
+      alloc_info->set_payload(source);
+    }
   }
 
   if (adjusted_object_size > object_size) {
     AllocationSiteInfo* alloc_info = reinterpret_cast<AllocationSiteInfo*>(
         reinterpret_cast<Address>(clone) + object_size);
     alloc_info->set_map(allocation_site_info_map());
     alloc_info->set_payload(source);
   }
 
   SLOW_ASSERT(
@@ skipping 399 matching lines @@
   HeapObject::cast(result)->set_map_no_write_barrier(string_map());
   String::cast(result)->set_length(length);
   String::cast(result)->set_hash_field(String::kEmptyHashField);
   ASSERT_EQ(size, HeapObject::cast(result)->Size());
   return result;
 }
 
 
 MaybeObject* Heap::AllocateJSArray(
     ElementsKind elements_kind,
-    PretenureFlag pretenure) {
+    PretenureFlag pretenure,
+    AllocationSiteMode mode,
+    Handle<Object>* allocation_site_info_payload) {
   Context* native_context = isolate()->context()->native_context();
   JSFunction* array_function = native_context->array_function();
   Map* map = array_function->initial_map();
   Object* maybe_map_array = native_context->js_array_maps();
   if (!maybe_map_array->IsUndefined()) {
     Object* maybe_transitioned_map =
         FixedArray::cast(maybe_map_array)->get(elements_kind);
     if (!maybe_transitioned_map->IsUndefined()) {
       map = Map::cast(maybe_transitioned_map);
     }
   }
 
-  return AllocateJSObjectFromMap(map, pretenure);
+  return AllocateJSObjectFromMap(map, pretenure, mode,
+                                 allocation_site_info_payload);
 }
 
 
 MaybeObject* Heap::AllocateEmptyFixedArray() {
   int size = FixedArray::SizeFor(0);
   Object* result;
   { MaybeObject* maybe_result =
         AllocateRaw(size, OLD_DATA_SPACE, OLD_DATA_SPACE);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
@@ skipping 2625 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