Create an abstraction (MarkBit) object to hold the location of the...

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 34 matching lines @@
     MarkObjectByPointer(p);
   }
 
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) MarkObjectByPointer(p);
   }
 
  private:
   // Mark object pointed to by p.
   INLINE(static void MarkObjectByPointer(Object** p)) {
-    if ((*p)->IsHeapObject()) {
-      HeapObject* object = HeapObject::cast(*p);
-      if (IncrementalMarking::IsWhite(object)) {
-        IncrementalMarking::WhiteToGrey(object);
+    Object* obj = *p;
+    if (obj->IsHeapObject()) {
+      HeapObject* heap_object = HeapObject::cast(obj);
+      MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
+      if (IncrementalMarking::IsWhite(mark_bit)) {
+        IncrementalMarking::WhiteToGrey(heap_object, mark_bit);
       }
     }
   }
 };
 
 
 static IncrementalMarkingMarkingVisitor marking_visitor;
 
 class IncrementalMarkingRootMarkingVisitor : public ObjectVisitor {
  public:
   void VisitPointer(Object** p) {
     MarkObjectByPointer(p);
   }
 
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) MarkObjectByPointer(p);
   }
 
  private:
   void MarkObjectByPointer(Object** p) {
-    if (!(*p)->IsHeapObject()) return;
+    Object* obj = *p;
+    if (!obj->IsHeapObject()) return;
 
-    HeapObject* object = HeapObject::cast(*p);
-    if (IncrementalMarking::IsWhite(object)) {
-      IncrementalMarking::WhiteToGrey(object);
+    HeapObject* heap_object = HeapObject::cast(obj);
+    MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
+    if (IncrementalMarking::IsWhite(mark_bit)) {
+      IncrementalMarking::WhiteToGrey(heap_object, mark_bit);
     }
   }
 };
 
 
 static void ClearMarkbits(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
     Page* p = it.next();
@@ skipping 76 matching lines @@
 
   PatchIncrementalMarkingRecordWriteStubs(true);
 
   Heap::EnsureFromSpaceIsCommitted();
 
   // Initialize marking stack.
   marking_stack_.Initialize(Heap::new_space()->FromSpaceLow(),
                             Heap::new_space()->FromSpaceHigh());
 
   // Clear markbits.
-  Address new_space_top = Heap::new_space()->top();
   Address new_space_bottom = Heap::new_space()->bottom();
+  uintptr_t new_space_size =
+      RoundUp(Heap::new_space()->top() - new_space_bottom, 32 * kPointerSize);
 
-  Marking::ClearRange(new_space_bottom,
-                      static_cast<int>(new_space_top - new_space_bottom));
+  Marking::ClearRange(new_space_bottom, new_space_size);
 
   ClearMarkbits();
 
 #ifdef DEBUG
   VerifyMarkbitsAreClean();
 #endif
 
   // Mark strong roots grey.
   IncrementalMarkingRootMarkingVisitor visitor;
   Heap::IterateStrongRoots(&visitor, VISIT_ONLY_STRONG);
@@ skipping 15 matching lines @@
     // TODO(gc) hurry can mark objects it encounters black as mutator
     // was stopped.
     Map* filler_map = Heap::one_pointer_filler_map();
     while (!marking_stack_.is_empty()) {
       HeapObject* obj = marking_stack_.Pop();
 
       // Explicitly skip one word fillers. Incremental markbit patterns are
       // correct only for objects that occupy at least two words.
       if (obj->map() != filler_map) {
         obj->Iterate(&marking_visitor);
-        MarkBlack(obj); }
+        MarkBit mark_bit = Marking::MarkBitFrom(obj);
+        MarkBlack(mark_bit);
+      }
     }
     state_ = COMPLETE;
     if (FLAG_trace_incremental_marking) {
       double end = OS::TimeCurrentMillis();
       PrintF("[IncrementalMarking] Complete (hurry), spent %d ms\n",
              static_cast<int>(end - start));
     }
   }
 }
 
@@ skipping 29 matching lines @@
         start = OS::TimeCurrentMillis();
       }
 
       Map* filler_map = Heap::one_pointer_filler_map();
       while (!marking_stack_.is_empty() && bytes_to_process > 0) {
         HeapObject* obj = marking_stack_.Pop();
 
         // Explicitly skip one word fillers. Incremental markbit patterns are
         // correct only for objects that occupy at least two words.
         if (obj->map() != filler_map) {
-          ASSERT(IsGrey(obj));
+          ASSERT(IsGrey(Marking::MarkBitFrom(obj)));
           Map* map = obj->map();
           int size = obj->SizeFromMap(map);
           bytes_to_process -= size;
-          if (IsWhite(map)) WhiteToGrey(map);
+          MarkBit map_mark_bit = Marking::MarkBitFrom(map);
+          if (IsWhite(map_mark_bit)) WhiteToGrey(map, map_mark_bit);
           obj->IterateBody(map->instance_type(), size, &marking_visitor);
-          MarkBlack(obj);
+          MarkBit obj_mark_bit = Marking::MarkBitFrom(obj);
+          MarkBlack(obj_mark_bit);
         }
         count++;
       }
       if (FLAG_trace_incremental_marking) {
         double end = OS::TimeCurrentMillis();
         PrintF("[IncrementalMarking]     %d objects marked, spent %d ms\n",
                count,
                static_cast<int>(end - start));
       }
       allocated = 0;
       if (marking_stack_.is_empty()) MarkingComplete();
     }
   }
 }
 
 
 } }  // namespace v8::internal