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 499 matching lines @@
     int dont_tenure_decisions = 0;
     int allocation_mementos_found = 0;
 
     Object* cur = allocation_sites_list();
     while (cur->IsAllocationSite()) {
       AllocationSite* casted = AllocationSite::cast(cur);
       allocation_mementos_found += casted->memento_found_count()->value();
       if (casted->DigestPretenuringFeedback()) {
         if (casted->GetPretenureMode() == TENURED) {
           tenure_decisions++;
+          casted->dependent_code()->DeoptimizeDependentCodeGroup(
+              isolate_,
+              DependentCode::kAllocationSiteTenuringChangedGroup);
         } else {
           dont_tenure_decisions++;
         }
       }
       cur = casted->weak_next();
     }
 
     // TODO(mvstanton): Pretenure decisions are only made once for an allocation
     // site. Find a sane way to decide about revisiting the decision later.
 
@@ skipping 535 matching lines @@
       IsHighSurvivalRate()) {
     // Stable high survival rates even though young generation is at
     // maximum capacity indicates that most objects will be promoted.
     // To decrease scavenger pauses and final mark-sweep pauses, we
     // have to limit maximal capacity of the young generation.
     SetNewSpaceHighPromotionModeActive(true);
     if (FLAG_trace_gc) {
       PrintPID("Limited new space size due to high promotion rate: %d MB\n",
                new_space_.InitialCapacity() / MB);
     }
-    // Support for global pre-tenuring uses the high promotion mode as a
-    // heuristic indicator of whether to pretenure or not, we trigger
-    // deoptimization here to take advantage of pre-tenuring as soon as
-    // possible.
-    if (FLAG_pretenuring) {
-      isolate_->stack_guard()->FullDeopt();
-    }
   } else if (new_space_high_promotion_mode_active_ &&
       IsStableOrDecreasingSurvivalTrend() &&
       IsLowSurvivalRate()) {
     // Decreasing low survival rates might indicate that the above high
     // promotion mode is over and we should allow the young generation
     // to grow again.
     SetNewSpaceHighPromotionModeActive(false);
     if (FLAG_trace_gc) {
       PrintPID("Unlimited new space size due to low promotion rate: %d MB\n",
                new_space_.MaximumCapacity() / MB);
     }
-    // Trigger deoptimization here to turn off pre-tenuring as soon as
-    // possible.
-    if (FLAG_pretenuring) {
-      isolate_->stack_guard()->FullDeopt();
-    }
   }
 
   if (new_space_high_promotion_mode_active_ &&
       new_space_.Capacity() > new_space_.InitialCapacity()) {
     new_space_.Shrink();
   }
 
   isolate_->counters()->objs_since_last_young()->Set(0);
 
   // Callbacks that fire after this point might trigger nested GCs and
@@ skipping 69 matching lines @@
       }
     }
   }
 }
 
 
 void Heap::MarkCompact(GCTracer* tracer) {
   gc_state_ = MARK_COMPACT;
   LOG(isolate_, ResourceEvent("markcompact", "begin"));
 
+  int64_t objects_before_gc = SizeOfObjects();
+
   mark_compact_collector_.Prepare(tracer);
 
   ms_count_++;
   tracer->set_full_gc_count(ms_count_);
 
   MarkCompactPrologue();
 
   mark_compact_collector_.CollectGarbage();
 
   LOG(isolate_, ResourceEvent("markcompact", "end"));
 
   gc_state_ = NOT_IN_GC;
 
   isolate_->counters()->objs_since_last_full()->Set(0);
 
   flush_monomorphic_ics_ = false;
+
+  EvaluateLocalPretenuring(objects_before_gc);
 }
 
 
 void Heap::MarkCompactPrologue() {
   // At any old GC clear the keyed lookup cache to enable collection of unused
   // maps.
   isolate_->keyed_lookup_cache()->Clear();
   isolate_->context_slot_cache()->Clear();
   isolate_->descriptor_lookup_cache()->Clear();
   RegExpResultsCache::Clear(string_split_cache());
@@ skipping 719 matching lines @@
 void Heap::ProcessAllocationSites(WeakObjectRetainer* retainer,
                                   bool record_slots) {
   Object* allocation_site_obj =
       VisitWeakList<AllocationSite>(this,
                                     allocation_sites_list(),
                                     retainer, record_slots);
   set_allocation_sites_list(allocation_site_obj);
 }
 
 
+void Heap::DeoptAllAllocationSitesDependentCode() {
+  Object* cur = allocation_sites_list();
+  while (cur->IsAllocationSite()) {
+    AllocationSite* casted = AllocationSite::cast(cur);
+    casted->dependent_code()->DeoptimizeDependentCodeGroup(

[mvstanton, 2013/11/30 12:20:41]

This is a good thing, but don't you also need to reset the pretenure_decision
field in the allocation site? I think right now it won't know that the decision
needs to be revisited.

In fact, maybe there should be a method in AllocationSite that does these two
things, like ResetPretenureDecision(), which would naturally enough deopt any
code that depends on the previous value of that decision.

[Hannes Payer (out of office), 2013/12/02 11:27:15]

Done.

+        isolate_,
+        DependentCode::kAllocationSiteTenuringChangedGroup);
+    cur = casted->weak_next();
+  }
+}
+
+
+void Heap::EvaluateLocalPretenuring(int64_t objects_before_gc) {

[mvstanton, 2013/11/30 12:20:41]

objects_before_gc: Can you get "sizeof" in the name of this variable? I'm
confused about what it is...# of objects, total byte size of them, etc.

[Hannes Payer (out of office), 2013/12/02 11:27:15]

Done.

+  int64_t objects_after_gc = SizeOfObjects();
+  int64_t old_generation_survival_rate =
+      (objects_after_gc * 100) / objects_before_gc;
+
+  if (old_generation_survival_rate < kOldSurvivalRateLowThreshold) {
+    // Too many objects died in the old generation, pretenuring of wrong
+    // allocation sites may be the cause for that. We have to deopt all
+    // dependent code registered in the allocation sites to re-evaluate
+    // our pretenuring decisions.
+    DeoptAllAllocationSitesDependentCode();
+    if (FLAG_trace_pretenuring) {
+      PrintF("Deopt all allocation sites dependent code due to low survival "
+             "rate in the old generation %d\n",
+             static_cast<intptr_t>(old_generation_survival_rate));
+    }
+  }
+}
+
+
 void Heap::VisitExternalResources(v8::ExternalResourceVisitor* visitor) {
   DisallowHeapAllocation no_allocation;
 
   // Both the external string table and the string table may contain
   // external strings, but neither lists them exhaustively, nor is the
   // intersection set empty.  Therefore we iterate over the external string
   // table first, ignoring internalized strings, and then over the
   // internalized string table.
 
   class ExternalStringTableVisitorAdapter : public ObjectVisitor {
@@ skipping 6036 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