Fix to allocation stub invalidation: we cannot just remove it as it will be collected even though c…

runtime/vm/heap.cc

 // 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.
 
 #include "vm/heap.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/object_set.h"
 #include "vm/os.h"
 #include "vm/pages.h"
 #include "vm/raw_object.h"
 #include "vm/scavenger.h"
 #include "vm/service.h"
 #include "vm/stack_frame.h"
 #include "vm/tags.h"
 #include "vm/verifier.h"
 #include "vm/virtual_memory.h"
 #include "vm/weak_table.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, verbose_gc, false, "Enables verbose GC.");
-DEFINE_FLAG(int, verbose_gc_hdr, 40, "Print verbose GC header interval.");
-DEFINE_FLAG(bool, verify_before_gc, false,
-            "Enables heap verification before GC.");
-DEFINE_FLAG(bool, verify_after_gc, false,
-            "Enables heap verification after GC.");
+DEFINE_FLAG(bool, disable_alloc_stubs_after_gc, false, "Stress testing flag.");
 DEFINE_FLAG(bool, gc_at_alloc, false, "GC at every allocation.");
 DEFINE_FLAG(int, new_gen_ext_limit, 64,
             "maximum total external size (MB) in new gen before triggering GC");
+DEFINE_FLAG(int, pretenure_interval, 10,
+            "Back off pretenuring after this many cycles.");
 DEFINE_FLAG(int, pretenure_threshold, 98,
             "Trigger pretenuring when this many percent are promoted.");
-DEFINE_FLAG(int, pretenure_interval, 10,
-            "Back off pretenuring after this many cycles.");
+DEFINE_FLAG(bool, verbose_gc, false, "Enables verbose GC.");
+DEFINE_FLAG(int, verbose_gc_hdr, 40, "Print verbose GC header interval.");
+DEFINE_FLAG(bool, verify_after_gc, false,
+            "Enables heap verification after GC.");
+DEFINE_FLAG(bool, verify_before_gc, false,
+            "Enables heap verification before GC.");
+
 
 Heap::Heap(Isolate* isolate,
            intptr_t max_new_gen_semi_words,
            intptr_t max_old_gen_words)
     : isolate_(isolate),
       read_only_(false),
       gc_in_progress_(false),
       pretenure_policy_(0) {
   for (int sel = 0;
        sel < kNumWeakSelectors;
@@ skipping 306 matching lines @@
 bool Heap::ShouldPretenure(intptr_t class_id) const {
   if (class_id == kOneByteStringCid) {
     return pretenure_policy_ > 0;
   } else {
     return false;
   }
 }
 
 
 void Heap::UpdatePretenurePolicy() {
+  if (FLAG_disable_alloc_stubs_after_gc) {
+    ClassTable* table = isolate_->class_table();
+    for (intptr_t cid = kNumPredefinedCids; cid < table->NumCids(); ++cid) {
+      if (table->IsValidIndex(cid) && table->HasValidClassAt(cid)) {
+        const Class& cls = Class::Handle(isolate_, table->At(cid));
+        cls.DisableAllocationStub();
+      }
+    }
+  }
   ClassHeapStats* stats =
       isolate_->class_table()->StatsWithUpdatedSize(kOneByteStringCid);
   int allocated = stats->pre_gc.new_count;
   int promo_percent = (allocated == 0) ? 0 :
       (100 * stats->promoted_count) / allocated;
   if (promo_percent >= FLAG_pretenure_threshold) {
     pretenure_policy_ += FLAG_pretenure_interval;
   } else {
     pretenure_policy_ = Utils::Maximum(0, pretenure_policy_ - 1);
   }
@@ skipping 312 matching lines @@
     heap->DisableGrowthControl();
 }
 
 
 NoHeapGrowthControlScope::~NoHeapGrowthControlScope() {
     Heap* heap = reinterpret_cast<Isolate*>(isolate())->heap();
     heap->SetGrowthControlState(current_growth_controller_state_);
 }
 
 }  // namespace dart