Thread-local store buffers, v2

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 62 matching lines @@
  private:
   bool* _addr;
   bool _value;
 };
 
 
 class ScavengerVisitor : public ObjectPointerVisitor {
  public:
   explicit ScavengerVisitor(Isolate* isolate, Scavenger* scavenger)
       : ObjectPointerVisitor(isolate),
+        thread_(Thread::Current()),
         scavenger_(scavenger),
         from_start_(scavenger_->from_->start()),
         from_size_(scavenger_->from_->end() - scavenger_->from_->start()),
         heap_(scavenger->heap_),
         vm_heap_(Dart::vm_isolate()->heap()),
         page_space_(scavenger->heap_->old_space()),
         delayed_weak_stack_(),
         bytes_promoted_(0),
         visiting_old_object_(NULL),
         in_scavenge_pointer_(false) { }
@@ skipping 39 matching lines @@
     uword ptr = reinterpret_cast<uword>(p);
     ASSERT(obj->IsHeapObject());
     ASSERT(!scavenger_->Contains(ptr));
     ASSERT(!heap_->CodeContains(ptr));
     ASSERT(heap_->Contains(ptr));
     // If the newly written object is not a new object, drop it immediately.
     if (!obj->IsNewObject() || visiting_old_object_->IsRemembered()) {
       return;
     }
     visiting_old_object_->SetRememberedBit();
-    isolate()->store_buffer()->AddObjectGC(visiting_old_object_);
+    thread_->StoreBufferAddObjectGC(visiting_old_object_);
   }
 
   void ScavengePointer(RawObject** p) {
     // ScavengePointer cannot be called recursively.
 #ifdef DEBUG
     ASSERT(!in_scavenge_pointer_);
     BoolScope bs(&in_scavenge_pointer_, true);
 #endif
 
     RawObject* raw_obj = *p;
@@ skipping 79 matching lines @@
     // Update the reference.
     RawObject* new_obj = RawObject::FromAddr(new_addr);
     *p = new_obj;
     // Update the store buffer as needed.
     if (visiting_old_object_ != NULL) {
       VerifiedMemory::Accept(reinterpret_cast<uword>(p), sizeof(*p));
       UpdateStoreBuffer(p, new_obj);
     }
   }
 
+  Thread* thread_;
   Scavenger* scavenger_;
   uword from_start_;
   uword from_size_;
   Heap* heap_;
   Heap* vm_heap_;
   PageSpace* page_space_;
   typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
   DelaySet delay_set_;
   GrowableArray<RawObject*> delayed_weak_stack_;
   // TODO(cshapiro): use this value to compute survival statistics for
@@ skipping 197 matching lines @@
   } else {
     return old_size_in_words;
   }
 }
 
 
 void Scavenger::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks && (isolate->gc_prologue_callback() != NULL)) {
     (isolate->gc_prologue_callback())();
   }
+  Thread::PrepareForGC();
   // Flip the two semi-spaces so that to_ is always the space for allocating
   // objects.
   from_ = to_;
   to_ = SemiSpace::New(NewSizeInWords(from_->size_in_words()));
   if (to_ == NULL) {
     // TODO(koda): We could try to recover (collect old space, wait for another
     // isolate to finish scavenge, etc.).
     FATAL("Out of memory.\n");
   }
   top_ = FirstObjectStart();
@@ skipping 37 matching lines @@
   from_->Delete();
   from_ = NULL;
   if (invoke_api_callbacks && (isolate->gc_epilogue_callback() != NULL)) {
     (isolate->gc_epilogue_callback())();
   }
 }
 
 
 void Scavenger::IterateStoreBuffers(Isolate* isolate,
                                     ScavengerVisitor* visitor) {
-  StoreBuffer* buffer = isolate->store_buffer();
-  heap_->RecordData(kStoreBufferEntries, buffer->Count());
-
   // Iterating through the store buffers.
-  // Grab the deduplication sets out of the store buffer.
+  // Grab the deduplication sets out of the isolate's consolidated store buffer.
   StoreBufferBlock* pending = isolate->store_buffer()->Blocks();
+  intptr_t total_count = 0;
   while (pending != NULL) {
     StoreBufferBlock* next = pending->next();
     // Generated code appends to store buffers; tell MemorySanitizer.
     MSAN_UNPOISON(pending, sizeof(*pending));
     intptr_t count = pending->Count();
+    total_count += count;
     for (intptr_t i = 0; i < count; i++) {
       RawObject* raw_object = pending->At(i);
       ASSERT(raw_object->IsRemembered());
       raw_object->ClearRememberedBit();
       visitor->VisitingOldObject(raw_object);
       raw_object->VisitPointers(visitor);
     }
     delete pending;
     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.
   visitor->VisitingOldObject(NULL);
 }
 
 
 void Scavenger::IterateObjectIdTable(Isolate* isolate,
                                      ScavengerVisitor* visitor) {
   ObjectIdRing* ring = isolate->object_id_ring();
@@ skipping 352 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart