Grow new gen (1M -> 4M -> 16M on 32-bit) when there is little garbage.

runtime/vm/scavenger.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_SCAVENGER_H_
 #define VM_SCAVENGER_H_
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/dart.h"
@@ skipping 16 matching lines @@
 DECLARE_FLAG(bool, gc_at_alloc);
 
 
 // Wrapper around VirtualMemory that adds caching and handles the empty case.
 class SemiSpace {
  public:
   static void InitOnce();
 
   // Get a space of the given size. Returns NULL on out of memory. If size is 0,
   // returns an empty space: pointer(), start() and end() all return NULL.
-  static SemiSpace* New(intptr_t size);
+  static SemiSpace* New(intptr_t size_in_words);
 
   // Hand back an unused space.
   void Delete();
 
   void* pointer() const { return region_.pointer(); }
   uword start() const { return region_.start(); }
   uword end() const { return region_.end(); }
-  intptr_t size() const { return static_cast<intptr_t>(region_.size()); }
+  intptr_t size_in_words() const {
+    return static_cast<intptr_t>(region_.size()) >> kWordSizeLog2;
+  }
   bool Contains(uword address) const { return region_.Contains(address); }
 
   // Set write protection mode for this space. The space must not be protected
   // when Delete is called.
   // TODO(koda): Remember protection mode in VirtualMemory and assert this.
   void WriteProtect(bool read_only);
 
  private:
   explicit SemiSpace(VirtualMemory* reserved);
   ~SemiSpace();
@@ skipping 46 matching lines @@
   int64_t end_micros_;
   SpaceUsage before_;
   SpaceUsage after_;
   intptr_t promo_candidates_in_words_;
   intptr_t promoted_in_words_;
 };
 
 
 class Scavenger {
  public:
-  Scavenger(Heap* heap, intptr_t max_capacity_in_words, uword object_alignment);
+  Scavenger(Heap* heap,
+            intptr_t max_semi_capacity_in_words,
+            uword object_alignment);
   ~Scavenger();
 
   // Check whether this Scavenger contains this address.
   // During scavenging both the to and from spaces contain "legal" objects.
   // During a scavenge this function only returns true for addresses that will
   // be part of the surviving objects.
   bool Contains(uword addr) const {
     // No reasonable algorithm should be checking for objects in from space. At
     // least unless it is debugging code. This might need to be relaxed later,
     // but currently it helps prevent dumb bugs.
@@ skipping 31 matching lines @@
   // Accessors to generate code for inlined allocation.
   uword* TopAddress() { return &top_; }
   uword* EndAddress() { return &end_; }
   static intptr_t top_offset() { return OFFSET_OF(Scavenger, top_); }
   static intptr_t end_offset() { return OFFSET_OF(Scavenger, end_); }
 
   intptr_t UsedInWords() const {
     return (top_ - FirstObjectStart()) >> kWordSizeLog2;
   }
   intptr_t CapacityInWords() const {
-    return to_->size() >> kWordSizeLog2;
+    return to_->size_in_words();
   }
   intptr_t ExternalInWords() const {
     return external_size_ >> kWordSizeLog2;
   }
   SpaceUsage GetCurrentUsage() const {
     SpaceUsage usage;
     usage.used_in_words = UsedInWords();
     usage.capacity_in_words = CapacityInWords();
     usage.external_in_words = ExternalInWords();
     return usage;
@@ skipping 83 matching lines @@
     ASSERT(end_ <= to_->end());
     return result;
   }
   bool PromotedStackHasMore() const {
     ASSERT(scavenging_);
     return end_ < to_->end();
   }
 
   void ProcessWeakTables();
 
+  intptr_t NewSizeInWords(intptr_t old_size_in_words) const;
+
   SemiSpace* from_;
   SemiSpace* to_;
 
   Heap* heap_;
 
   // Current allocation top and end. These values are being accessed directly
   // from generated code.
   uword top_;
   uword end_;
 
   // A pointer to the first unscanned object.  Scanning completes when
   // this value meets the allocation top.
   uword resolved_top_;
 
   // Objects below this address have survived a scavenge.
   uword survivor_end_;
 
+  intptr_t max_semi_capacity_in_words_;
+
   // All object are aligned to this value.
   uword object_alignment_;
 
   // Keep track whether a scavenge is currently running.
   bool scavenging_;
 
   int64_t gc_time_micros_;
   intptr_t collections_;
   static const int kStatsHistoryCapacity = 2;
   RingBuffer<ScavengeStats, kStatsHistoryCapacity> stats_history_;
 
   // The total size of external data associated with objects in this scavenger.
   intptr_t external_size_;
 
   friend class ScavengerVisitor;
   friend class ScavengerWeakVisitor;
 
   DISALLOW_COPY_AND_ASSIGN(Scavenger);
 };
 
 }  // namespace dart
 
 #endif  // VM_SCAVENGER_H_