Nonvirtual pointer visitor in GCs

runtime/vm/gc_marker.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/gc_marker.h"
 
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
@@ skipping 174 matching lines @@
       RawObject* raw_key = cur_weak->ptr()->key_;
       // Reset the next pointer in the weak property.
       cur_weak->ptr()->next_ = 0;
       if (raw_key->IsMarked()) {
         RawObject* raw_val = cur_weak->ptr()->value_;
         marked = marked || (raw_val->IsHeapObject() && !raw_val->IsMarked());
 
         // The key is marked so we make sure to properly visit all pointers
         // originating from this weak property.
         VisitingOldObject(cur_weak);
-        cur_weak->VisitPointers(this);
+        cur_weak->VisitPointersNonvirtual(this);
       } else {
         // Requeue this weak property to be handled later.
         EnqueueWeakProperty(cur_weak);
       }
       // Advance to next weak property in the queue.
       cur_weak = reinterpret_cast<RawWeakProperty*>(next_weak);
     }
     VisitingOldObject(NULL);
     return marked;
   }
 
   void DrainMarkingStack() {
     RawObject* raw_obj = work_list_.Pop();
     if ((raw_obj == NULL) && ProcessPendingWeakProperties()) {
       raw_obj = work_list_.Pop();
     }
 
     if (raw_obj == NULL) {
       ASSERT(visiting_old_object_ == NULL);
       return;
     }
     do {
       do {
         // First drain the marking stacks.
         VisitingOldObject(raw_obj);
         const intptr_t class_id = raw_obj->GetClassId();
         if (class_id != kWeakPropertyCid) {
-          marked_bytes_ += raw_obj->VisitPointers(this);
+          marked_bytes_ += raw_obj->VisitPointersNonvirtual(this);
         } else {
           RawWeakProperty* raw_weak =
               reinterpret_cast<RawWeakProperty*>(raw_obj);
           marked_bytes_ += ProcessWeakProperty(raw_weak);
         }
         raw_obj = work_list_.Pop();
       } while (raw_obj != NULL);
 
       // Marking stack is empty.
       ProcessPendingWeakProperties();
@@ skipping 31 matching lines @@
   intptr_t ProcessWeakProperty(RawWeakProperty* raw_weak) {
     // The fate of the weak property is determined by its key.
     RawObject* raw_key = raw_weak->ptr()->key_;
     if (raw_key->IsHeapObject() && raw_key->IsOldObject() &&
         !raw_key->IsMarked()) {
       // Key was 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(this);
+    return raw_weak->VisitPointersNonvirtual(this);

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

I don't think this is worth it.  Normally there are a lot more non-weak pointers
on the heap than weak pointers. ALso another place in this file.

   }
 
   // Called when all marking is complete.
   void Finalize() {
     work_list_.Finalize();
     // Detach code from functions.
     if (skipped_code_functions_ != NULL) {
       skipped_code_functions_->DetachCode();
     }
     // Clear pending weak properties.
@@ skipping 472 matching lines @@
       // Phase 3: Finalize results from all markers (detach code, etc.).
       barrier.Exit();
     }
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart