Use worst-fit allocation in old space for prentured objects.

src/heap.h

 // 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 1506 matching lines @@
   // Predicate that governs global pre-tenuring decisions based on observed
   // promotion rates of previous collections.
   inline bool ShouldGloballyPretenure() {
     return new_space_high_promotion_mode_active_;
   }
 
   inline intptr_t PromotedTotalSize() {
     return PromotedSpaceSizeOfObjects() + PromotedExternalMemorySize();
   }
 
+  // TODO(hpayer): When we provide pretenuring support for all kinds of
+  // objects we can change this heuristic and make it depend on the high
+  // promotion mode.
+  inline bool AggressivePromotionMode() {
+    return PretenuredSizeOfObjects() > 0;
+  }
+
+  inline int OldGenerationHighPromotionFactor() {
+    return AggressivePromotionMode() ? 2 : 1;
+  }
+
   // True if we have reached the allocation limit in the old generation that
   // should force the next GC (caused normally) to be a full one.
   inline bool OldGenerationPromotionLimitReached() {
-    return PromotedTotalSize() > old_gen_promotion_limit_;
+    return PromotedTotalSize() >
+        old_gen_promotion_limit_ * OldGenerationHighPromotionFactor();
   }
 
   inline intptr_t OldGenerationSpaceAvailable() {
     return old_gen_allocation_limit_ - PromotedTotalSize();
   }
 
   inline intptr_t OldGenerationCapacityAvailable() {
     return max_old_generation_size_ - PromotedTotalSize();
   }
 
@@ skipping 83 matching lines @@
   }
 
   inline bool NextGCIsLikelyToBeFull() {
     if (FLAG_gc_global) return true;
 
     if (FLAG_stress_compaction && (gc_count_ & 1) != 0) return true;
 
     intptr_t total_promoted = PromotedTotalSize();
 
     intptr_t adjusted_promotion_limit =
-        old_gen_promotion_limit_ - new_space_.Capacity();
+        old_gen_promotion_limit_ * OldGenerationHighPromotionFactor() -
+            new_space_.Capacity();
 
     if (total_promoted >= adjusted_promotion_limit) return true;
 
     intptr_t adjusted_allocation_limit =
-        old_gen_allocation_limit_ - new_space_.Capacity() / 5;
+        old_gen_allocation_limit_ * OldGenerationHighPromotionFactor() -
+            new_space_.Capacity() / 5;
 
     if (PromotedSpaceSizeOfObjects() >= adjusted_allocation_limit) return true;
 
     return false;
   }
 
 
   void UpdateNewSpaceReferencesInExternalStringTable(
       ExternalStringTableUpdaterCallback updater_func);
 
@@ skipping 14 matching lines @@
 
   void ClearJSFunctionResultCaches();
 
   void ClearNormalizedMapCaches();
 
   GCTracer* tracer() { return tracer_; }
 
   // Returns the size of objects residing in non new spaces.
   intptr_t PromotedSpaceSizeOfObjects();
 
+  // TODO(hpayer): We can remove PretenuredSizeOfObjects() when
+  // we provide pretenuring support for all kinds of objects.
+  intptr_t PretenuredSizeOfObjects();
+
   double total_regexp_code_generated() { return total_regexp_code_generated_; }
   void IncreaseTotalRegexpCodeGenerated(int size) {
     total_regexp_code_generated_ += size;
   }
 
   // Returns maximum GC pause.
   double get_max_gc_pause() { return max_gc_pause_; }
 
   // Returns maximum size of objects alive after GC.
   intptr_t get_max_alive_after_gc() { return max_alive_after_gc_; }
@@ skipping 1336 matching lines @@
   AssertNoAllocation no_alloc;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_