Nonvirtual pointer visitor in GCs

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 "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 451 matching lines @@
     while (!pending->IsEmpty()) {
       RawObject* raw_object = pending->Pop();
       if (raw_object->IsForwardingCorpse()) {
         // A source object in a become was a remembered object, but we do
         // not visit the store buffer during become to remove it.
         continue;
       }
       ASSERT(raw_object->IsRemembered());
       raw_object->ClearRememberedBit();
       visitor->VisitingOldObject(raw_object);
-      raw_object->VisitPointers(visitor);
+      raw_object->VisitPointersNonvirtual(visitor);
     }
     pending->Reset();
     // Return the emptied block for recycling (no need to check threshold).
     isolate->store_buffer()->PushBlock(pending, StoreBuffer::kIgnoreThreshold);
     pending = next;
   }
   heap_->RecordData(kStoreBufferEntries, total_count);
   heap_->RecordData(kDataUnused1, 0);
   heap_->RecordData(kDataUnused2, 0);
   // Done iterating through old objects remembered in the store buffers.
@@ skipping 60 matching lines @@
 }
 
 
 void Scavenger::ProcessToSpace(ScavengerVisitor* visitor) {
   // Iterate until all work has been drained.
   while ((resolved_top_ < top_) || PromotedStackHasMore()) {
     while (resolved_top_ < top_) {
       RawObject* raw_obj = RawObject::FromAddr(resolved_top_);
       intptr_t class_id = raw_obj->GetClassId();
       if (class_id != kWeakPropertyCid) {
-        resolved_top_ += raw_obj->VisitPointers(visitor);
+        resolved_top_ += raw_obj->VisitPointersNonvirtual(visitor);
       } else {
         RawWeakProperty* raw_weak = reinterpret_cast<RawWeakProperty*>(raw_obj);
         resolved_top_ += ProcessWeakProperty(raw_weak, visitor);
       }
     }
     {
       // Visit all the promoted objects and update/scavenge their internal
       // pointers. Potentially this adds more objects to the to space.
       while (PromotedStackHasMore()) {
         RawObject* raw_object = RawObject::FromAddr(PopFromPromotedStack());
         // Resolve or copy all objects referred to by the current object. This
         // can potentially push more objects on this stack as well as add more
         // objects to be resolved in the to space.
         ASSERT(!raw_object->IsRemembered());
         visitor->VisitingOldObject(raw_object);
-        raw_object->VisitPointers(visitor);
+        raw_object->VisitPointersNonvirtual(visitor);
       }
       visitor->VisitingOldObject(NULL);
     }
     {
       // Finished this round of scavenging. Process the pending weak properties
       // for which the keys have become reachable. Potentially this adds more
       // objects to the to space.
       RawWeakProperty* cur_weak = delayed_weak_properties_;
       delayed_weak_properties_ = NULL;
       while (cur_weak != NULL) {
         uword next_weak = cur_weak->ptr()->next_;
         // Promoted weak properties are not enqueued. So we can guarantee that
         // we do not need to think about store barriers here.
         ASSERT(cur_weak->IsNewObject());
         RawObject* raw_key = cur_weak->ptr()->key_;
         ASSERT(raw_key->IsHeapObject());
         // Key still points into from space even if the object has been
         // promoted to old space by now. The key will be updated accordingly
         // below when VisitPointers is run.
         ASSERT(raw_key->IsNewObject());
         uword raw_addr = RawObject::ToAddr(raw_key);
         ASSERT(visitor->from_->Contains(raw_addr));
         uword header = *reinterpret_cast<uword*>(raw_addr);
         // Reset the next pointer in the weak property.
         cur_weak->ptr()->next_ = 0;
         if (IsForwarding(header)) {
-          cur_weak->VisitPointers(visitor);
+          cur_weak->VisitPointersNonvirtual(visitor);

[erikcorry, 2017/05/31 10:40:42]

Probably not worth it.

         } else {
           EnqueueWeakProperty(cur_weak);
         }
         // Advance to next weak property in the queue.
         cur_weak = reinterpret_cast<RawWeakProperty*>(next_weak);
       }
     }
   }
 }
 
@@ skipping 47 matching lines @@
   if (raw_key->IsHeapObject() && raw_key->IsNewObject()) {
     uword raw_addr = RawObject::ToAddr(raw_key);
     uword header = *reinterpret_cast<uword*>(raw_addr);
     if (!IsForwarding(header)) {
       // Key is white.  Enqueue the weak property.
       EnqueueWeakProperty(raw_weak);
       return raw_weak->Size();
     }
   }
   // Key is gray or black.  Make the weak property black.
-  return raw_weak->VisitPointers(visitor);
+  return raw_weak->VisitPointersNonvirtual(visitor);

[erikcorry, 2017/05/31 10:40:42]

Probably not worth it.

 }
 
 
 void Scavenger::ProcessWeakReferences() {
   // Rehash the weak tables now that we know which objects survive this cycle.
   for (int sel = 0; sel < Heap::kNumWeakSelectors; sel++) {
     WeakTable* table =
         heap_->GetWeakTable(Heap::kNew, static_cast<Heap::WeakSelector>(sel));
     heap_->SetWeakTable(Heap::kNew, static_cast<Heap::WeakSelector>(sel),
                         WeakTable::NewFrom(table));
@@ skipping 215 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart