Bookkeeping for allocation site pretenuring

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 1529 matching lines @@
   LOG(isolate_, ResourceEvent("scavenge", "end"));
 
   gc_state_ = NOT_IN_GC;
 
   scavenges_since_last_idle_round_++;
 
   if (FLAG_trace_track_allocation_sites && allocation_mementos_found_ > 0) {
     PrintF("AllocationMementos found during scavenge = %d\n",
            allocation_mementos_found_);
   }
+
+  if (FLAG_allocation_site_pretenuring) {
+    int pretenure_decisions_made = 0;
+    Object* cur = allocation_sites_list();
+    if (cur->IsAllocationSite()) {
+      while (cur->IsAllocationSite()) {
+        AllocationSite* casted = AllocationSite::cast(cur);
+        if (!(casted->DecisionMade())) {

[Hannes Payer (out of office), 2013/11/21 20:52:24]

See the other comment about not enough allocation mementos created - here I
would stay in undecided mode.

[mvstanton, 2013/11/22 11:18:51]

I've simplified and encapsulated this code in a way that also respects a minimum
number of mementos found.

+          casted->Decide();
+          if (casted->GetPretenureMode() == TENURED) {
+            pretenure_decisions_made++;
+          }
+        }
+        casted->Clear();
+        cur = casted->weak_next();
+      }
+    }

[Hannes Payer (out of office), 2013/11/21 20:52:24]

Right now we do not support switching state which is OK. But let's add a TODO
here.

[mvstanton, 2013/11/22 11:18:51]

Done.

+
+    if (FLAG_trace_track_allocation_sites && pretenure_decisions_made > 0) {
+      PrintF("Scavenge: pretenure decisions made: %d\n",
+             pretenure_decisions_made);
+    }
+  }
 }
 
 
 String* Heap::UpdateNewSpaceReferenceInExternalStringTableEntry(Heap* heap,
                                                                 Object** p) {
   MapWord first_word = HeapObject::cast(*p)->map_word();
 
   if (!first_word.IsForwardingAddress()) {
     // Unreachable external string can be finalized.
     heap->FinalizeExternalString(String::cast(*p));
@@ skipping 2809 matching lines @@
   Object* 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);
   AllocationMemento* alloc_memento = reinterpret_cast<AllocationMemento*>(
       reinterpret_cast<Address>(result) + map->instance_size());
   alloc_memento->set_map_no_write_barrier(allocation_memento_map());
   ASSERT(allocation_site->map() == allocation_site_map());
   alloc_memento->set_allocation_site(*allocation_site, SKIP_WRITE_BARRIER);
+  if (FLAG_allocation_site_pretenuring) {
+    allocation_site->IncrementMementoCreateCount();

[Hannes Payer (out of office), 2013/11/21 20:52:24]

I am wondering if this counter is not only interesting for pretenuring but also
for other clients of allocation mementos.

[mvstanton, 2013/11/22 11:18:51]

Maybe so, but not yet. I like the idea of keeping all this infrastructure behind
the pretenuring flag for now, at least until there is another client or we can
get rid of the flag.

+  }
   return result;
 }
 
 
 MaybeObject* Heap::Allocate(Map* map, AllocationSpace space) {
   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 =
@@ skipping 412 matching lines @@
 MaybeObject* Heap::CopyJSObject(JSObject* source, AllocationSite* site) {
   // 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;
 
-  ASSERT(site == NULL || (AllocationSite::CanTrack(map->instance_type()) &&
-                          map->instance_type() == JS_ARRAY_TYPE));
+  ASSERT(site == NULL || AllocationSite::CanTrack(map->instance_type()));
 
   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;
     }
@@ skipping 21 matching lines @@
     CopyBlock(HeapObject::cast(clone)->address(),
               source->address(),
               object_size);
 
     if (site != NULL) {
       AllocationMemento* alloc_memento = reinterpret_cast<AllocationMemento*>(
           reinterpret_cast<Address>(clone) + object_size);
       alloc_memento->set_map_no_write_barrier(allocation_memento_map());
       ASSERT(site->map() == allocation_site_map());
       alloc_memento->set_allocation_site(site, SKIP_WRITE_BARRIER);
+      if (FLAG_allocation_site_pretenuring) {
+        site->IncrementMementoCreateCount();
+      }
       HeapProfiler* profiler = isolate()->heap_profiler();
       if (profiler->is_tracking_allocations()) {
         profiler->UpdateObjectSizeEvent(HeapObject::cast(clone)->address(),
                                         object_size);
         profiler->NewObjectEvent(alloc_memento->address(),
                                  AllocationMemento::kSize);
       }
     }
   }
 
@@ skipping 3091 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   OS::MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   OS::MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal