Simpler, more consistent triggering of old GC; also, use external in policy.

runtime/vm/scavenger.cc

 // Copyright (c) 2011, 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.
 
 #include "vm/scavenger.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
@@ skipping 61 matching lines @@
 class ScavengerVisitor : public ObjectPointerVisitor {
  public:
   explicit ScavengerVisitor(Isolate* isolate, Scavenger* scavenger)
       : ObjectPointerVisitor(isolate),
         scavenger_(scavenger),
         heap_(scavenger->heap_),
         vm_heap_(Dart::vm_isolate()->heap()),
         visited_count_(0),
         handled_count_(0),
         delayed_weak_stack_(),
-        growth_policy_(PageSpace::kControlGrowth),
         bytes_promoted_(0),
         visiting_old_object_(NULL),
         in_scavenge_pointer_(false) { }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       ScavengePointer(current);
     }
   }
 
@@ skipping 100 matching lines @@
         // to space.
         new_addr = scavenger_->TryAllocate(size);
         class_table->UpdateLiveNew(cid, size);
       } else {
         // TODO(iposva): Experiment with less aggressive promotion. For example
         // a coin toss determines if an object is promoted or whether it should
         // survive in this generation.
         //
         // This object is a survivor of a previous scavenge. Attempt to promote
         // the object.
-        new_addr = heap_->TryAllocate(size, Heap::kOld, growth_policy_);
+        new_addr =
+            heap_->TryAllocate(size, Heap::kOld, PageSpace::kForceGrowth);
         if (new_addr != 0) {
           // If promotion succeeded then we need to remember it so that it can
           // be traversed later.
           scavenger_->PushToPromotedStack(new_addr);
           bytes_promoted_ += size;
           class_table->UpdateAllocatedOld(cid, size);
-        } else if (!scavenger_->had_promotion_failure_) {
-          // Signal a promotion failure and set the growth policy for
-          // this, and all subsequent promotion allocations, to force
-          // growth.
-          scavenger_->had_promotion_failure_ = true;
-          growth_policy_ = PageSpace::kForceGrowth;
-          new_addr = heap_->TryAllocate(size, Heap::kOld, growth_policy_);
-          if (new_addr != 0) {
-            scavenger_->PushToPromotedStack(new_addr);
-            bytes_promoted_ += size;
-            class_table->UpdateAllocatedOld(cid, size);
-          } else {
-            // Promotion did not succeed. Copy into the to space
-            // instead.
-            new_addr = scavenger_->TryAllocate(size);
-            class_table->UpdateLiveNew(cid, size);
-          }
         } else {
-          ASSERT(growth_policy_ == PageSpace::kForceGrowth);
           // Promotion did not succeed. Copy into the to space instead.
           new_addr = scavenger_->TryAllocate(size);
           class_table->UpdateLiveNew(cid, size);
         }
       }
       // During a scavenge we always succeed to at least copy all of the
       // current objects to the to space.
       ASSERT(new_addr != 0);
       // Copy the object to the new location.
       memmove(reinterpret_cast<void*>(new_addr),
@@ skipping 12 matching lines @@
   }
 
   Scavenger* scavenger_;
   Heap* heap_;
   Heap* vm_heap_;
   intptr_t visited_count_;
   intptr_t handled_count_;
   typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
   DelaySet delay_set_;
   GrowableArray<RawObject*> delayed_weak_stack_;
-  PageSpace::GrowthPolicy growth_policy_;
   // TODO(cshapiro): use this value to compute survival statistics for
   // new space growth policy.
   intptr_t bytes_promoted_;
   RawObject* visiting_old_object_;
   bool in_scavenge_pointer_;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerVisitor);
 };
 
 
@@ skipping 422 matching lines @@
   // TODO(cshapiro): Add a decision procedure for determining when the
   // the API callbacks should be invoked.
   Scavenge(false);
 }
 
 
 void Scavenger::Scavenge(bool invoke_api_callbacks) {
   // Scavenging is not reentrant. Make sure that is the case.
   ASSERT(!scavenging_);
   scavenging_ = true;
-  had_promotion_failure_ = false;
   Isolate* isolate = Isolate::Current();
   NoHandleScope no_handles(isolate);
 
   if (FLAG_verify_before_gc) {
     OS::PrintErr("Verifying before Scavenge...");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
   // Setup the visitor and run a scavenge.
@@ skipping 54 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart