Distinct block sizes for StoreBuffer/MarkingStack.

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 <map>
 #include <utility>
 #include <vector>
 
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/pages.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/store_buffer.h"
 #include "vm/thread_barrier.h"
 #include "vm/thread_pool.h"
 #include "vm/visitor.h"
 #include "vm/object_id_ring.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, marker_tasks, 1,
             "The number of tasks to spawn during old gen GC marking (0 means "
             "perform all marking on main thread).");
 
-typedef StoreBufferBlock PointerBlock;  // TODO(koda): Rename to PointerBlock.
-typedef StoreBuffer MarkingStack;  // TODO(koda): Create shared base class.
-
 class DelaySet {
  private:
   typedef std::multimap<RawObject*, RawWeakProperty*> Map;
   typedef std::pair<RawObject*, RawWeakProperty*> MapEntry;
 
  public:
   DelaySet() : mutex_(new Mutex()) {}
   ~DelaySet() { delete mutex_; }
 
   // Returns 'true' if this inserted a new key (not just added a value).
@@ skipping 238 matching lines @@
       ASSERT(work_ == NULL);
       ASSERT(marking_stack_ == NULL);
     }
 
     // Returns NULL if no more work was found.
     RawObject* Pop() {
       ASSERT(work_ != NULL);
       if (work_->IsEmpty()) {
         // TODO(koda): Track over/underflow events and use in heuristics to
         // distribute work and prevent degenerate flip-flopping.
-        PointerBlock* new_work = marking_stack_->PopNonEmptyBlock();
+        MarkingStack::Block* new_work = marking_stack_->PopNonEmptyBlock();
         if (new_work == NULL) {
           return NULL;
         }
-        marking_stack_->PushBlock(work_, false);
+        marking_stack_->PushBlock(work_);
         work_ = new_work;
       }
       return work_->Pop();
     }
 
     void Push(RawObject* raw_obj) {
       if (work_->IsFull()) {
         // TODO(koda): Track over/underflow events and use in heuristics to
         // distribute work and prevent degenerate flip-flopping.
-        marking_stack_->PushBlock(work_, false);
+        marking_stack_->PushBlock(work_);
         work_ = marking_stack_->PopEmptyBlock();
       }
       work_->Push(raw_obj);
     }
 
     void Finalize() {
       ASSERT(work_->IsEmpty());
-      marking_stack_->PushBlock(work_, false);
+      marking_stack_->PushBlock(work_);
       work_ = NULL;
       // Fail fast on attempts to mark after finalizing.
       marking_stack_ = NULL;
     }
 
    private:
-    PointerBlock* work_;
+    MarkingStack::Block* work_;
     MarkingStack* marking_stack_;
   };
 
   void MarkAndPush(RawObject* raw_obj) {
     ASSERT(raw_obj->IsHeapObject());
     ASSERT((FLAG_verify_before_gc || FLAG_verify_before_gc) ?
            page_space_->Contains(RawObject::ToAddr(raw_obj)) :
            true);
 
     // Mark the object and push it on the marking stack.
@@ skipping 380 matching lines @@
       barrier.Exit();
     }
     delay_set.ClearReferences();
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart