Remove support for object grouping during Garbage Collection

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 237 matching lines @@
   intptr_t bytes_promoted_;
   RawObject* visiting_old_object_;
   bool in_scavenge_pointer_;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerVisitor);
 };
 
 
 class ScavengerWeakVisitor : public HandleVisitor {
  public:
-  // 'prologue_weak_were_strong' is currently only used for sanity checking.
-  explicit ScavengerWeakVisitor(Scavenger* scavenger,
-                                bool prologue_weak_were_strong)
+  explicit ScavengerWeakVisitor(Scavenger* scavenger)
       :  HandleVisitor(Thread::Current()),
-         scavenger_(scavenger),
-         prologue_weak_were_strong_(prologue_weak_were_strong) {
+         scavenger_(scavenger) {
     ASSERT(scavenger->heap_->isolate() == Thread::Current()->isolate());
   }
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
       reinterpret_cast<FinalizablePersistentHandle*>(addr);
     RawObject** p = handle->raw_addr();
     if (scavenger_->IsUnreachable(p)) {
-      ASSERT(!handle->IsPrologueWeakPersistent() ||
-             !prologue_weak_were_strong_);
       handle->UpdateUnreachable(thread()->isolate());
     } else {
       handle->UpdateRelocated(thread()->isolate());
     }
   }
 
  private:
   Scavenger* scavenger_;
-  bool prologue_weak_were_strong_;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerWeakVisitor);
 };
 
 
 // Visitor used to verify that all old->new references have been added to the
 // StoreBuffers.
 class VerifyStoreBufferPointerVisitor : public ObjectPointerVisitor {
  public:
   VerifyStoreBufferPointerVisitor(Isolate* isolate,
@@ skipping 261 matching lines @@
   ObjectIdRing* ring = isolate->object_id_ring();
   if (ring == NULL) {
     // --gc_at_alloc can get us here before the ring has been initialized.
     ASSERT(FLAG_gc_at_alloc);
     return;
   }
   ring->VisitPointers(visitor);
 }
 
 
-void Scavenger::IterateRoots(Isolate* isolate,
-                             ScavengerVisitor* visitor,
-                             bool visit_prologue_weak_persistent_handles) {
+void Scavenger::IterateRoots(Isolate* isolate, ScavengerVisitor* visitor) {
   int64_t start = OS::GetCurrentTimeMicros();
   isolate->VisitObjectPointers(visitor,
-                               visit_prologue_weak_persistent_handles,
                                StackFrameIterator::kDontValidateFrames);
   int64_t middle = OS::GetCurrentTimeMicros();
   IterateStoreBuffers(isolate, visitor);
   IterateObjectIdTable(isolate, visitor);
   int64_t end = OS::GetCurrentTimeMicros();
   heap_->RecordData(kToKBAfterStoreBuffer, RoundWordsToKB(UsedInWords()));
   heap_->RecordTime(kVisitIsolateRoots, middle - start);
   heap_->RecordTime(kIterateStoreBuffers, end - middle);
 }
 
@@ skipping 13 matching lines @@
   uword header = *reinterpret_cast<uword*>(raw_addr);
   if (IsForwarding(header)) {
     uword new_addr = ForwardedAddr(header);
     *p = RawObject::FromAddr(new_addr);
     return false;
   }
   return true;
 }
 
 
-void Scavenger::IterateWeakReferences(Isolate* isolate,
-                                      ScavengerVisitor* visitor) {
-  ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
-  while (true) {
-    WeakReferenceSet* queue = state->delayed_weak_reference_sets();
-    if (queue == NULL) {
-      // The delay queue is empty therefore no clean-up is required.
-      return;
-    }
-    state->set_delayed_weak_reference_sets(NULL);
-    while (queue != NULL) {
-      WeakReferenceSet* reference_set = WeakReferenceSet::Pop(&queue);
-      ASSERT(reference_set != NULL);
-      intptr_t num_keys = reference_set->num_keys();
-      intptr_t num_values = reference_set->num_values();
-      if ((num_keys == 1) && (num_values == 1) &&
-          reference_set->SingletonKeyEqualsValue()) {
-        // We do not have to process sets that have just one key/value pair
-        // and the key and value are identical.
-        continue;
-      }
-      bool is_unreachable = true;
-      // Test each key object for reachability.  If a key object is
-      // reachable, all value objects should be scavenged.
-      for (intptr_t k = 0; k < num_keys; ++k) {
-        if (!IsUnreachable(reference_set->get_key(k))) {
-          for (intptr_t v = 0; v < num_values; ++v) {
-            RawObject** raw_obj_addr = reference_set->get_value(v);
-            RawObject* raw_obj = *raw_obj_addr;
-            // Only visit heap objects which are in from space, aka new objects
-            // not in to space. This avoids visiting a value multiple times
-            // during a scavenge.
-            if (raw_obj->IsHeapObject() &&
-                raw_obj->IsNewObject() &&
-                !to_->Contains(RawObject::ToAddr(raw_obj))) {
-              visitor->VisitPointer(raw_obj_addr);
-            }
-          }
-          is_unreachable = false;
-          // Since we have found a key object that is reachable and all
-          // value objects have been marked we can break out of iterating
-          // this set and move on to the next set.
-          break;
-        }
-      }
-      // If all key objects are unreachable put the reference on a
-      // delay queue.  This reference will be revisited if another
-      // reference is scavenged.
-      if (is_unreachable) {
-        state->DelayWeakReferenceSet(reference_set);
-      }
-    }
-    if ((resolved_top_ < top_) || PromotedStackHasMore()) {
-      ProcessToSpace(visitor);
-    } else {
-      // Break out of the loop if there has been no forward process.
-      // All key objects in the weak reference sets are unreachable
-      // so we reset the weak reference sets queue.
-      state->set_delayed_weak_reference_sets(NULL);
-      break;
-    }
-  }
-  ASSERT(state->delayed_weak_reference_sets() == NULL);
-  // All weak reference sets are zone allocated and unmarked references which
-  // were on the delay queue will be freed when the zone is released in the
-  // epilog callback.
+void Scavenger::IterateWeakRoots(Isolate* isolate, HandleVisitor* visitor) {
+  isolate->VisitWeakPersistentHandles(visitor);
 }
 
 
-void Scavenger::IterateWeakRoots(Isolate* isolate,
-                                 HandleVisitor* visitor,
-                                 bool visit_prologue_weak_persistent_handles) {
-  isolate->VisitWeakPersistentHandles(visitor,
-                                      visit_prologue_weak_persistent_handles);
-}
-
-
 void Scavenger::ProcessToSpace(ScavengerVisitor* visitor) {
   GrowableArray<RawObject*>* delayed_weak_stack = visitor->DelayedWeakStack();
 
   // Iterate until all work has been drained.
   while ((resolved_top_ < top_) ||
          PromotedStackHasMore() ||
          !delayed_weak_stack->is_empty()) {
     while (resolved_top_ < top_) {
       RawObject* raw_obj = RawObject::FromAddr(resolved_top_);
       intptr_t class_id = raw_obj->GetClassId();
@@ skipping 175 matching lines @@
   intptr_t promo_candidate_words =
       (survivor_end_ - FirstObjectStart()) / kWordSize;
   SemiSpace* from = Prologue(isolate, invoke_api_callbacks);
   // The API prologue/epilogue may create/destroy zones, so we must not
   // depend on zone allocations surviving beyond the epilogue callback.
   {
     StackZone zone(Thread::Current());
     // Setup the visitor and run the scavenge.
     ScavengerVisitor visitor(isolate, this, from);
     page_space->AcquireDataLock();
-    const bool prologue_weak_are_strong = !invoke_api_callbacks;
-    IterateRoots(isolate, &visitor, prologue_weak_are_strong);
+    IterateRoots(isolate, &visitor);
     int64_t start = OS::GetCurrentTimeMicros();
     ProcessToSpace(&visitor);
     int64_t middle = OS::GetCurrentTimeMicros();
-    IterateWeakReferences(isolate, &visitor);
-    ScavengerWeakVisitor weak_visitor(this, prologue_weak_are_strong);
-    // Include the prologue weak handles, since we must process any promotion.
-    const bool visit_prologue_weak_handles = true;
-    IterateWeakRoots(isolate, &weak_visitor, visit_prologue_weak_handles);
+    ScavengerWeakVisitor weak_visitor(this);
+    IterateWeakRoots(isolate, &weak_visitor);
     visitor.Finalize();
     ProcessWeakTables();
     page_space->ReleaseDataLock();
 
     // Scavenge finished. Run accounting.
     int64_t end = OS::GetCurrentTimeMicros();
     heap_->RecordTime(kProcessToSpace, middle - start);
     heap_->RecordTime(kIterateWeaks, end - middle);
     stats_history_.Add(
         ScavengeStats(start, end,
@@ skipping 56 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart