Check the growth of the old generation before expanding the paged...

src/heap.cc

 // Copyright 2006-2008 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 46 matching lines @@
   SYMBOL_LIST(SYMBOL_ALLOCATION)
 #undef SYMBOL_ALLOCATION
 
 NewSpace Heap::new_space_;
 OldSpace* Heap::old_pointer_space_ = NULL;
 OldSpace* Heap::old_data_space_ = NULL;
 OldSpace* Heap::code_space_ = NULL;
 MapSpace* Heap::map_space_ = NULL;
 LargeObjectSpace* Heap::lo_space_ = NULL;
 
-int Heap::promoted_space_limit_ = 0;
+static const int kMinimumPromotionLimit = 2*MB;
+static const int kMinimumAllocationLimit = 8*MB;
+
+int Heap::old_gen_promotion_limit_ = kMinimumPromotionLimit;
+int Heap::old_gen_allocation_limit_ = kMinimumAllocationLimit;
+
 int Heap::old_gen_exhausted_ = false;
 
 int Heap::amount_of_external_allocated_memory_ = 0;
 int Heap::amount_of_external_allocated_memory_at_last_global_gc_ = 0;
 
 // semispace_size_ should be a power of 2 and old_generation_size_ should be
 // a multiple of Page::kPageSize.
 int Heap::semispace_size_  = 2*MB;
 int Heap::old_generation_size_ = 512*MB;
 int Heap::initial_semispace_size_ = 256*KB;
@@ skipping 53 matching lines @@
 
 
 GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space) {
   // Is global GC requested?
   if (space != NEW_SPACE || FLAG_gc_global) {
     Counters::gc_compactor_caused_by_request.Increment();
     return MARK_COMPACTOR;
   }
 
   // Is enough data promoted to justify a global GC?
-  if (PromotedSpaceSize() + PromotedExternalMemorySize()
-      > promoted_space_limit_) {
+  if (OldGenerationPromotionLimitReached()) {
     Counters::gc_compactor_caused_by_promoted_data.Increment();
     return MARK_COMPACTOR;
   }
 
   // Have allocation in OLD and LO failed?
   if (old_gen_exhausted_) {
     Counters::gc_compactor_caused_by_oldspace_exhaustion.Increment();
     return MARK_COMPACTOR;
   }
 
@@ skipping 200 matching lines @@
                                     GarbageCollector collector,
                                     GCTracer* tracer) {
   if (collector == MARK_COMPACTOR && global_gc_prologue_callback_) {
     ASSERT(!allocation_allowed_);
     global_gc_prologue_callback_();
   }
 
   if (collector == MARK_COMPACTOR) {
     MarkCompact(tracer);
 
-    int promoted_space_size = PromotedSpaceSize();
-    promoted_space_limit_ =
-        promoted_space_size + Max(2 * MB, (promoted_space_size/100) * 35);
+    int old_gen_size = PromotedSpaceSize();
+    old_gen_promotion_limit_ =
+        old_gen_size + Max(kMinimumPromotionLimit, old_gen_size / 3);
+    old_gen_allocation_limit_ =
+        old_gen_size + Max(kMinimumAllocationLimit, old_gen_size / 3);
     old_gen_exhausted_ = false;
 
     // If we have used the mark-compact collector to collect the new
     // space, and it has not compacted the new space, we force a
     // separate scavenge collection.  This is a hack.  It covers the
     // case where (1) a new space collection was requested, (2) the
     // collector selection policy selected the mark-compact collector,
     // and (3) the mark-compact collector policy selected not to
     // compact the new space.  In that case, there is no more (usable)
     // free space in the new space after the collection compared to
@@ skipping 1908 matching lines @@
 
 
 // This function expects that NewSpace's allocated objects histogram is
 // populated (via a call to CollectStatistics or else as a side effect of a
 // just-completed scavenge collection).
 void Heap::ReportHeapStatistics(const char* title) {
   USE(title);
   PrintF(">>>>>> =============== %s (%d) =============== >>>>>>\n",
          title, gc_count_);
   PrintF("mark-compact GC : %d\n", mc_count_);
-  PrintF("promoted_space_limit_ %d\n", promoted_space_limit_);
+  PrintF("old_gen_promotion_limit_ %d\n", old_gen_promotion_limit_);
+  PrintF("old_gen_allocation_limit_ %d\n", old_gen_allocation_limit_);
 
   PrintF("\n");
   PrintF("Number of handles : %d\n", HandleScope::NumberOfHandles());
   GlobalHandles::PrintStats();
   PrintF("\n");
 
   PrintF("Heap statistics : ");
   MemoryAllocator::ReportStatistics();
   PrintF("To space : ");
   new_space_.ReportStatistics();
@@ skipping 881 matching lines @@
 #ifdef DEBUG
 bool Heap::GarbageCollectionGreedyCheck() {
   ASSERT(FLAG_gc_greedy);
   if (Bootstrapper::IsActive()) return true;
   if (disallow_allocation_failure()) return true;
   return CollectGarbage(0, NEW_SPACE);
 }
 #endif
 
 } }  // namespace v8::internal