Make backing store for incremental marking deque non-static.

src/incremental-marking.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 20 matching lines @@
 
 #include "code-stubs.h"
 
 namespace v8 {
 namespace internal {
 
 
 IncrementalMarking::IncrementalMarking(Heap* heap)
     : heap_(heap),
       state_(STOPPED),
+      marking_deque_memory_(NULL),
       steps_count_(0),
       steps_took_(0),
       should_hurry_(false),
       allocation_marking_factor_(0),
       allocated_(0) {
 }
 
 
+void IncrementalMarking::TearDown() {
+  delete marking_deque_memory_;
+}
+
+
 void IncrementalMarking::RecordWriteFromCode(HeapObject* obj,
                                              Object* value,
                                              Isolate* isolate) {
   isolate->heap()->incremental_marking()->RecordWrite(obj, value);
 }
 
 
 class IncrementalMarkingMarkingVisitor : public ObjectVisitor {
  public:
   IncrementalMarkingMarkingVisitor(Heap* heap,
@@ skipping 205 matching lines @@
         Object* e = stubs->ValueAt(i);
         if (e->IsCode()) {
           RecordWriteStub::Patch(Code::cast(e), enable);
         }
       }
     }
   }
 }
 
 
-static VirtualMemory* marking_deque_memory = NULL;
-
-
-static void EnsureMarkingDequeIsCommitted() {
-  if (marking_deque_memory == NULL) {
-    marking_deque_memory = new VirtualMemory(4 * MB);
-    marking_deque_memory->Commit(
-        reinterpret_cast<Address>(marking_deque_memory->address()),
-        marking_deque_memory->size(),
+void IncrementalMarking::EnsureMarkingDequeIsCommitted() {
+  if (marking_deque_memory_ == NULL) {
+    marking_deque_memory_ = new VirtualMemory(4 * MB);
+    marking_deque_memory_->Commit(
+        reinterpret_cast<Address>(marking_deque_memory_->address()),
+        marking_deque_memory_->size(),
         false);  // Not executable.
   }
 }
 
 
 void IncrementalMarking::Start() {
   if (FLAG_trace_incremental_marking) {
     PrintF("[IncrementalMarking] Start\n");
   }
   ASSERT(FLAG_incremental_marking);
@@ skipping 20 matching lines @@
     PrintF("[IncrementalMarking] Start marking\n");
   }
 
   state_ = MARKING;
 
   PatchIncrementalMarkingRecordWriteStubs(true);
 
   EnsureMarkingDequeIsCommitted();
 
   // Initialize marking stack.
-  Address addr = static_cast<Address>(marking_deque_memory->address());
-  int size = marking_deque_memory->size();
+  Address addr = static_cast<Address>(marking_deque_memory_->address());
+  int size = marking_deque_memory_->size();
   if (FLAG_force_marking_deque_overflows) size = 64 * kPointerSize;
   marking_deque_.Initialize(addr, addr + size);
 
   // Clear markbits.
   ClearMarkbits();
 
 #ifdef DEBUG
   VerifyMarkbitsAreClean();
 #endif
 
@@ skipping 16 matching lines @@
 
 void IncrementalMarking::UpdateMarkingDequeAfterScavenge() {
   if (!IsMarking()) return;
 
   intptr_t current = marking_deque_.bottom();
   intptr_t mask = marking_deque_.mask();
   intptr_t limit = marking_deque_.top();
   HeapObject** array = marking_deque_.array();
   intptr_t new_top = current;
 
+  Map* filler_map = heap_->one_pointer_filler_map();
+
   while (current != limit) {
     HeapObject* obj = array[current];
     current = ((current + 1) & mask);
     if (heap_->InNewSpace(obj)) {
       MapWord map_word = obj->map_word();
       if (map_word.IsForwardingAddress()) {
         HeapObject* dest = map_word.ToForwardingAddress();
         array[new_top] = dest;
         new_top = ((new_top + 1) & mask);
         ASSERT(new_top != marking_deque_.bottom());
-        ASSERT(Marking::Color(obj) == Marking::Color(dest));
+        ASSERT(Marking::IsGrey(Marking::MarkBitFrom(obj)));
       }
-    } else {
+    } else if (obj->map() != filler_map) {

[Erik Corry, 2011/06/06 10:27:39]

It would be nice with a comment as to how these grey single-word fillers got to
be here.

       array[new_top] = obj;
       new_top = ((new_top + 1) & mask);
       ASSERT(new_top != marking_deque_.bottom());
+      ASSERT(Marking::IsGrey(Marking::MarkBitFrom(obj)));
     }
   }
   marking_deque_.set_top(new_top);
 }
 
 
 void IncrementalMarking::Hurry() {
   if (state() == MARKING) {
     double start = 0.0;
     if (FLAG_trace_incremental_marking) {
@@ skipping 132 matching lines @@
   }
 
   if (FLAG_trace_incremental_marking || FLAG_trace_gc) {
     double end = OS::TimeCurrentMillis();
     steps_took_ += (end - start);
   }
 }
 
 
 } }  // namespace v8::internal