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 3892 matching lines @@
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     code->Verify();
   }
 #endif
   return new_code;
 }
 
 
-MaybeObject* Heap::Allocate(Map* map, AllocationSpace space) {
+MaybeObject* Heap::Allocate(Map* map, AllocationSpace space,
+                            AllocationSiteMode mode,
+                            Handle<Object>* allocation_site_info_payload) {
   ASSERT(gc_state_ == NOT_IN_GC);
   ASSERT(map->instance_type() != MAP_TYPE);
+  ASSERT(allocation_site_info_payload != NULL ||
+         mode == DONT_TRACK_ALLOCATION_SITE);
+  ASSERT(space == NEW_SPACE || mode == DONT_TRACK_ALLOCATION_SITE);
   // 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());
+  int size = map->instance_size();
+  if (mode == TRACK_ALLOCATION_SITE) {
+    size += AllocationSiteInfo::kSize;
+  }
   Object* result;
-  { MaybeObject* maybe_result =
-        AllocateRaw(map->instance_size(), space, retry_space);
-    if (!maybe_result->ToObject(&result)) return maybe_result;
-  }
+  MaybeObject* maybe_result = AllocateRaw(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);
+  if (mode == TRACK_ALLOCATION_SITE) {
+    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;
 }
 
-
-// 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 =
-        AllocateRaw(map->instance_size() + AllocationSiteInfo::kSize,
-                    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);
-  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);
@@ skipping 219 matching lines @@
   } else {
     filler = Heap::undefined_value();
   }
   obj->InitializeBody(map, Heap::undefined_value(), filler);
 }
 
 
 MaybeObject* Heap::AllocateJSObjectFromMap(Map* map, PretenureFlag pretenure,
     AllocationSiteMode mode,
     Handle<Object>* allocation_site_info_payload) {
+  ASSERT(allocation_site_info_payload != NULL ||
+         mode == DONT_TRACK_ALLOCATION_SITE);
   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;
-    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;
-  }
+  MaybeObject* maybe_obj = Allocate(map, space, mode,
+                                    allocation_site_info_payload);
+  if (!maybe_obj->To(&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,
     AllocationSiteMode mode,
     Handle<Object>* allocation_site_info_payload) {
+  ASSERT(allocation_site_info_payload != NULL ||
+         mode == DONT_TRACK_ALLOCATION_SITE);
+  ASSERT(pretenure == NOT_TENURED || mode == DONT_TRACK_ALLOCATION_SITE);
   // 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, 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());
     JSGlobalPropertyCell* cell = JSGlobalPropertyCell::cast(
         **allocation_site_info_payload);
-    ASSERT(cell->value()->IsSmi());
     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);
-      // constructor->set_initial_map(Map::cast(initial_map));
-      // Map::cast(initial_map)->set_constructor(constructor);
-      mode = DONT_TRACK_ALLOCATION_SITE;
+      MaybeObject* maybe_new_map = constructor->GetElementsTransitionMap(
+          isolate(), to_kind);
+      if (!maybe_new_map->To(&initial_map)) return maybe_new_map;
+      // TODO(mvstanton): Is the line below useful for performance?
+      // mode = DONT_TRACK_ALLOCATION_SITE;

[Toon Verwaest, 2013/02/21 12:13:03]

Use GetMode(to_kind); here to decide whether or not to track ALLOCATION_SITE.

[mvstanton, 2013/02/27 14:37:07]

Done.

     }
   }
 
   MaybeObject* result = AllocateJSObjectFromMap(
       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());
@@ skipping 18 matching lines @@
 
 
 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);
   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");
-  }
+  ASSERT(pretenure == NOT_TENURED ||
+         allocation_site_info_mode == DONT_TRACK_ALLOCATION_SITE);
   MaybeObject* maybe_array = AllocateJSArray(elements_kind, pretenure,
                                              allocation_site_info_mode,
                                              allocation_site_payload);
   JSArray* array;
   if (!maybe_array->To(&array)) return maybe_array;
+  return AllocateJSArrayStorage(array, length, capacity, mode);
+}
+
+
+MaybeObject* Heap::AllocateJSArrayStorage(
+    JSArray* array,
+    int length,
+    int capacity,
+    ArrayStorageAllocationMode mode) {
+  ASSERT(capacity >= length);
 
   if (capacity == 0) {
     array->set_length(Smi::FromInt(0));
     array->set_elements(empty_fixed_array());
     return array;
   }
 
   FixedArrayBase* elms;
   MaybeObject* maybe_elms = NULL;
+  ElementsKind elements_kind = array->GetElementsKind();
   if (IsFastDoubleElementsKind(elements_kind)) {
     if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
       maybe_elms = AllocateUninitializedFixedDoubleArray(capacity);
     } else {
       ASSERT(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
       maybe_elms = AllocateFixedDoubleArrayWithHoles(capacity);
     }
   } else {
     ASSERT(IsFastSmiOrObjectElementsKind(elements_kind));
     if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
@@ skipping 3284 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