Thread-local store buffers, v2

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>
 
@@ skipping 110 matching lines @@
 
 
 class MarkingVisitor : public ObjectPointerVisitor {
  public:
   MarkingVisitor(Isolate* isolate,
                  Heap* heap,
                  PageSpace* page_space,
                  MarkingStack* marking_stack,
                  bool visit_function_code)
       : ObjectPointerVisitor(isolate),
+        thread_(Thread::Current()),
         heap_(heap),
         vm_heap_(Dart::vm_isolate()->heap()),
         class_table_(isolate->class_table()),
         page_space_(page_space),
         marking_stack_(marking_stack),
         visiting_old_object_(NULL),
         visit_function_code_(visit_function_code) {
     ASSERT(heap_ != vm_heap_);
+    ASSERT(thread_->isolate() == isolate);
   }
 
   MarkingStack* marking_stack() const { return marking_stack_; }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       MarkObject(*current, current);
     }
   }
 
@@ skipping 70 matching lines @@
       return;
     }
 
     // Skip over new objects, but verify consistency of heap while at it.
     if (raw_obj->IsNewObject()) {
       // TODO(iposva): Add consistency check.
       if ((visiting_old_object_ != NULL) &&
           !visiting_old_object_->IsRemembered()) {
         ASSERT(p != NULL);
         visiting_old_object_->SetRememberedBitUnsynchronized();
-        isolate()->store_buffer()->AddObjectGC(visiting_old_object_);
+        thread_->StoreBufferAddObjectGC(visiting_old_object_);
       }
       return;
     }
     if (RawObject::IsVariableSizeClassId(raw_obj->GetClassId())) {
       class_table_->UpdateLiveOld(raw_obj->GetClassId(), raw_obj->Size());
     } else {
       class_table_->UpdateLiveOld(raw_obj->GetClassId(), 0);
     }
 
     MarkAndPush(raw_obj);
@@ skipping 38 matching lines @@
         }
       }
     }
     if (FLAG_log_code_drop) {
       ISL_Print("  total detached current: %" Pd "\n", current_code_count);
       ISL_Print("  total detached unoptimized: %" Pd "\n",
                 unoptimized_code_count);
     }
   }
 
+  Thread* thread_;
   Heap* heap_;
   Heap* vm_heap_;
   ClassTable* class_table_;
   PageSpace* page_space_;
   MarkingStack* marking_stack_;
   RawObject* visiting_old_object_;
   typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
   typedef std::pair<RawObject*, RawWeakProperty*> DelaySetEntry;
   DelaySet delay_set_;
   const bool visit_function_code_;
@@ skipping 33 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MarkingWeakVisitor);
 };
 
 
 void GCMarker::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks && (isolate->gc_prologue_callback() != NULL)) {
     (isolate->gc_prologue_callback())();
   }
+  Thread::PrepareForGC();
   // The store buffers will be rebuilt as part of marking, reset them now.
   isolate->store_buffer()->Reset();
 }
 
 
 void GCMarker::Epilogue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks && (isolate->gc_epilogue_callback() != NULL)) {
     (isolate->gc_epilogue_callback())();
   }
 }
@@ skipping 183 matching lines @@
     MarkingWeakVisitor mark_weak;
     IterateWeakRoots(isolate, &mark_weak, invoke_api_callbacks);
     mark.Finalize();
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart