Only shrink new space when we are not in the process of obtaining pretenuring feedback.

src/heap/heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 512 matching lines @@
 
 void Heap::RepairFreeListsAfterDeserialization() {
   PagedSpaces spaces(this);
   for (PagedSpace* space = spaces.next(); space != NULL;
        space = spaces.next()) {
     space->RepairFreeListsAfterDeserialization();
   }
 }
 
 
-void Heap::ProcessPretenuringFeedback() {
+bool Heap::ProcessPretenuringFeedback() {
+  bool trigger_deoptimization = false;
   if (FLAG_allocation_site_pretenuring) {
     int tenure_decisions = 0;
     int dont_tenure_decisions = 0;
     int allocation_mementos_found = 0;
     int allocation_sites = 0;
     int active_allocation_sites = 0;
 
     // If the scratchpad overflowed, we have to iterate over the allocation
     // sites list.
     // TODO(hpayer): We iterate over the whole list of allocation sites when
     // we grew to the maximum semi-space size to deopt maybe tenured
     // allocation sites. We could hold the maybe tenured allocation sites
     // in a seperate data structure if this is a performance problem.
     bool deopt_maybe_tenured = DeoptMaybeTenuredAllocationSites();
     bool use_scratchpad =
         allocation_sites_scratchpad_length_ < kAllocationSiteScratchpadSize &&
         !deopt_maybe_tenured;
 
     int i = 0;
     Object* list_element = allocation_sites_list();
-    bool trigger_deoptimization = false;
     bool maximum_size_scavenge = MaximumSizeScavenge();
     while (use_scratchpad ? i < allocation_sites_scratchpad_length_
                           : list_element->IsAllocationSite()) {
       AllocationSite* site =
           use_scratchpad
               ? AllocationSite::cast(allocation_sites_scratchpad()->get(i))
               : AllocationSite::cast(list_element);
       allocation_mementos_found += site->memento_found_count();
       if (site->memento_found_count() > 0) {
         active_allocation_sites++;
@@ skipping 31 matching lines @@
          dont_tenure_decisions > 0)) {
       PrintF(
           "GC: (mode, #visited allocation sites, #active allocation sites, "
           "#mementos, #tenure decisions, #donttenure decisions) "
           "(%s, %d, %d, %d, %d, %d)\n",
           use_scratchpad ? "use scratchpad" : "use list", allocation_sites,
           active_allocation_sites, allocation_mementos_found, tenure_decisions,
           dont_tenure_decisions);
     }
   }
+  return trigger_deoptimization;
 }
 
 
 void Heap::DeoptMarkedAllocationSites() {
   // TODO(hpayer): If iterating over the allocation sites list becomes a
   // performance issue, use a cache heap data structure instead (similar to the
   // allocation sites scratchpad).
   Object* list_element = allocation_sites_list();
   while (list_element->IsAllocationSite()) {
     AllocationSite* site = AllocationSite::cast(list_element);
     if (site->deopt_dependent_code()) {
       site->dependent_code()->MarkCodeForDeoptimization(
           isolate_, DependentCode::kAllocationSiteTenuringChangedGroup);
       site->set_deopt_dependent_code(false);
     }
     list_element = site->weak_next();
   }
   Deoptimizer::DeoptimizeMarkedCode(isolate_);
 }
 
 
 void Heap::GarbageCollectionEpilogue() {
   store_buffer()->GCEpilogue();
 
   // In release mode, we only zap the from space under heap verification.
   if (Heap::ShouldZapGarbage()) {
     ZapFromSpace();
   }
 
-  // Process pretenuring feedback and update allocation sites.
-  ProcessPretenuringFeedback();
-
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     Verify();
   }
 #endif
 
   AllowHeapAllocation for_the_rest_of_the_epilogue;
 
 #ifdef DEBUG
   if (FLAG_print_global_handles) isolate_->global_handles()->Print();
@@ skipping 595 matching lines @@
     old_generation_size_configured_ = true;
     // This should be updated before PostGarbageCollectionProcessing, which can
     // cause another GC. Take into account the objects promoted during GC.
     old_generation_allocation_counter_ +=
         static_cast<size_t>(promoted_objects_size_);
     old_generation_size_at_last_gc_ = PromotedSpaceSizeOfObjects();
   } else {
     Scavenge();
   }
 
+  bool deopted = ProcessPretenuringFeedback();
+  UpdateSurvivalStatistics(start_new_space_size);
 
-  UpdateSurvivalStatistics(start_new_space_size);
-  ConfigureNewGenerationSize();
+  // When pretenuring is collecting new feedback, we do not shrink the new space
+  // right away.
+  if (!deopted) {
+    ConfigureNewGenerationSize();
+  }
   ConfigureInitialOldGenerationSize();
 
   isolate_->counters()->objs_since_last_young()->Set(0);
 
   if (collector != SCAVENGER) {
     // Callbacks that fire after this point might trigger nested GCs and
     // restart incremental marking, the assertion can't be moved down.
     DCHECK(incremental_marking()->IsStopped());
 
     // We finished a marking cycle. We can uncommit the marking deque until
@@ skipping 5495 matching lines @@
     *object_type = "CODE_TYPE";                                                \
     *object_sub_type = "CODE_AGE/" #name;                                      \
     return true;
     CODE_AGE_LIST_COMPLETE(COMPARE_AND_RETURN_NAME)
 #undef COMPARE_AND_RETURN_NAME
   }
   return false;
 }
 }  // namespace internal
 }  // namespace v8