Revert of [heap] Provide ObjectMarking with marking transitions

src/heap/incremental-marking.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/heap/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/conversions.h"
 #include "src/heap/gc-idle-time-handler.h"
@@ skipping 21 matching lines @@
       was_activated_(false),
       black_allocation_(false),
       finalize_marking_completed_(false),
       trace_wrappers_toggle_(false),
       request_type_(NONE),
       new_generation_observer_(*this, kAllocatedThreshold),
       old_generation_observer_(*this, kAllocatedThreshold) {}
 
 bool IncrementalMarking::BaseRecordWrite(HeapObject* obj, Object* value) {
   HeapObject* value_heap_obj = HeapObject::cast(value);
-  DCHECK(!ObjectMarking::IsImpossible(value_heap_obj));
-  DCHECK(!ObjectMarking::IsImpossible(obj));
-  const bool is_black = ObjectMarking::IsBlack(obj);
+  MarkBit value_bit = ObjectMarking::MarkBitFrom(value_heap_obj);
+  DCHECK(!Marking::IsImpossible(value_bit));
 
-  if (is_black && ObjectMarking::IsWhite(value_heap_obj)) {
-    WhiteToGreyAndPush(value_heap_obj);
+  MarkBit obj_bit = ObjectMarking::MarkBitFrom(obj);
+  DCHECK(!Marking::IsImpossible(obj_bit));
+  bool is_black = Marking::IsBlack(obj_bit);
+
+  if (is_black && Marking::IsWhite(value_bit)) {
+    WhiteToGreyAndPush(value_heap_obj, value_bit);
     RestartIfNotMarking();
   }
   return is_compacting_ && is_black;
 }
 
 
 void IncrementalMarking::RecordWriteSlow(HeapObject* obj, Object** slot,
                                          Object* value) {
   if (BaseRecordWrite(obj, value) && slot != NULL) {
     // Object is not going to be rescanned we need to record the slot.
@@ skipping 50 matching lines @@
 }
 
 void IncrementalMarking::RecordWriteIntoCodeSlow(Code* host, RelocInfo* rinfo,
                                                  Object* value) {
   if (BaseRecordWrite(host, value)) {
     // Object is not going to be rescanned.  We need to record the slot.
     heap_->mark_compact_collector()->RecordRelocSlot(host, rinfo, value);
   }
 }
 
-void IncrementalMarking::WhiteToGreyAndPush(HeapObject* obj) {
-  ObjectMarking::WhiteToGrey(obj);
+
+void IncrementalMarking::WhiteToGreyAndPush(HeapObject* obj, MarkBit mark_bit) {
+  Marking::WhiteToGrey(mark_bit);
   heap_->mark_compact_collector()->marking_deque()->Push(obj);
 }
 
 
 static void MarkObjectGreyDoNotEnqueue(Object* obj) {
   if (obj->IsHeapObject()) {
     HeapObject* heap_obj = HeapObject::cast(obj);
-    ObjectMarking::AnyToGrey(heap_obj);
+    MarkBit mark_bit = ObjectMarking::MarkBitFrom(HeapObject::cast(obj));
+    if (Marking::IsBlack(mark_bit)) {
+      MemoryChunk::IncrementLiveBytes(heap_obj, -heap_obj->Size());
+    }
+    Marking::AnyToGrey(mark_bit);
   }
 }
 
 void IncrementalMarking::TransferMark(Heap* heap, HeapObject* from,
                                       HeapObject* to) {
-  DCHECK(MemoryChunk::FromAddress(from->address())->SweepingDone());
   // This is only used when resizing an object.
   DCHECK(MemoryChunk::FromAddress(from->address()) ==
          MemoryChunk::FromAddress(to->address()));
 
   if (!heap->incremental_marking()->IsMarking()) return;
 
   // If the mark doesn't move, we don't check the color of the object.
   // It doesn't matter whether the object is black, since it hasn't changed
   // size, so the adjustment to the live data count will be zero anyway.
   if (from == to) return;
 
   MarkBit new_mark_bit = ObjectMarking::MarkBitFrom(to);
   MarkBit old_mark_bit = ObjectMarking::MarkBitFrom(from);
 
 #ifdef DEBUG
   Marking::ObjectColor old_color = Marking::Color(old_mark_bit);
 #endif
 
   if (Marking::IsBlack(old_mark_bit)) {
     Marking::BlackToWhite(old_mark_bit);
-    Marking::WhiteToBlack(new_mark_bit);
+    Marking::MarkBlack(new_mark_bit);
     return;
   } else if (Marking::IsGrey(old_mark_bit)) {
     Marking::GreyToWhite(old_mark_bit);
-    Marking::WhiteToGrey(new_mark_bit);
-    heap->mark_compact_collector()->marking_deque()->Push(to);
+    heap->incremental_marking()->WhiteToGreyAndPush(to, new_mark_bit);
     heap->incremental_marking()->RestartIfNotMarking();
   }
 
 #ifdef DEBUG
   Marking::ObjectColor new_color = Marking::Color(new_mark_bit);
   DCHECK(new_color == old_color);
 #endif
 }
 
 class IncrementalMarkingMarkingVisitor
@@ skipping 27 matching lines @@
       do {
         VisitPointers(heap, object, HeapObject::RawField(object, start_offset),
                       HeapObject::RawField(object, end_offset));
         start_offset = end_offset;
         end_offset = Min(object_size, end_offset + kProgressBarScanningChunk);
         scan_until_end =
             heap->mark_compact_collector()->marking_deque()->IsFull();
       } while (scan_until_end && start_offset < object_size);
       chunk->set_progress_bar(start_offset);
       if (start_offset < object_size) {
-        if (ObjectMarking::IsGrey(object)) {
+        if (Marking::IsGrey(ObjectMarking::MarkBitFrom(object))) {
           heap->mark_compact_collector()->marking_deque()->Unshift(object);
         } else {
-          DCHECK(ObjectMarking::IsBlack(object));
+          DCHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(object)));
           heap->mark_compact_collector()->UnshiftBlack(object);
         }
         heap->incremental_marking()->NotifyIncompleteScanOfObject(
             object_size - (start_offset - already_scanned_offset));
       }
     } else {
       FixedArrayVisitor::Visit(map, object);
     }
   }
 
@@ skipping 31 matching lines @@
 
   // Marks the object grey and pushes it on the marking stack.
   INLINE(static void MarkObject(Heap* heap, Object* obj)) {
     IncrementalMarking::MarkGrey(heap, HeapObject::cast(obj));
   }
 
   // Marks the object black without pushing it on the marking stack.
   // Returns true if object needed marking and false otherwise.
   INLINE(static bool MarkObjectWithoutPush(Heap* heap, Object* obj)) {
     HeapObject* heap_object = HeapObject::cast(obj);
-    if (ObjectMarking::IsWhite(heap_object)) {
-      ObjectMarking::WhiteToBlack(heap_object);
+    MarkBit mark_bit = ObjectMarking::MarkBitFrom(heap_object);
+    if (Marking::IsWhite(mark_bit)) {
+      Marking::MarkBlack(mark_bit);
+      MemoryChunk::IncrementLiveBytes(heap_object, heap_object->Size());
       return true;
     }
     return false;
   }
 };
 
 void IncrementalMarking::IterateBlackObject(HeapObject* object) {
-  if (IsMarking() && ObjectMarking::IsBlack(object)) {
+  if (IsMarking() && Marking::IsBlack(ObjectMarking::MarkBitFrom(object))) {
     Page* page = Page::FromAddress(object->address());
     if ((page->owner() != nullptr) && (page->owner()->identity() == LO_SPACE)) {
       // IterateBlackObject requires us to visit the whole object.
       page->ResetProgressBar();
     }
     Map* map = object->map();
     MarkGrey(heap_, map);
     IncrementalMarkingMarkingVisitor::IterateBody(map, object);
   }
 }
@@ skipping 364 matching lines @@
 }
 
 
 bool ShouldRetainMap(Map* map, int age) {
   if (age == 0) {
     // The map has aged. Do not retain this map.
     return false;
   }
   Object* constructor = map->GetConstructor();
   if (!constructor->IsHeapObject() ||
-      ObjectMarking::IsWhite(HeapObject::cast(constructor))) {
+      Marking::IsWhite(
+          ObjectMarking::MarkBitFrom(HeapObject::cast(constructor)))) {
     // The constructor is dead, no new objects with this map can
     // be created. Do not retain this map.
     return false;
   }
   return true;
 }
 
 
 void IncrementalMarking::RetainMaps() {
   // Do not retain dead maps if flag disables it or there is
   // - memory pressure (reduce_memory_footprint_),
   // - GC is requested by tests or dev-tools (abort_incremental_marking_).
   bool map_retaining_is_disabled = heap()->ShouldReduceMemory() ||
                                    heap()->ShouldAbortIncrementalMarking() ||
                                    FLAG_retain_maps_for_n_gc == 0;
   ArrayList* retained_maps = heap()->retained_maps();
   int length = retained_maps->Length();
   // The number_of_disposed_maps separates maps in the retained_maps
   // array that were created before and after context disposal.
   // We do not age and retain disposed maps to avoid memory leaks.
   int number_of_disposed_maps = heap()->number_of_disposed_maps_;
   for (int i = 0; i < length; i += 2) {
     DCHECK(retained_maps->Get(i)->IsWeakCell());
     WeakCell* cell = WeakCell::cast(retained_maps->Get(i));
     if (cell->cleared()) continue;
     int age = Smi::cast(retained_maps->Get(i + 1))->value();
     int new_age;
     Map* map = Map::cast(cell->value());
+    MarkBit map_mark = ObjectMarking::MarkBitFrom(map);
     if (i >= number_of_disposed_maps && !map_retaining_is_disabled &&
-        ObjectMarking::IsWhite(map)) {
+        Marking::IsWhite(map_mark)) {
       if (ShouldRetainMap(map, age)) {
         MarkGrey(heap(), map);
       }
       Object* prototype = map->prototype();
       if (age > 0 && prototype->IsHeapObject() &&
-          ObjectMarking::IsWhite(HeapObject::cast(prototype))) {
+          Marking::IsWhite(
+              ObjectMarking::MarkBitFrom(HeapObject::cast(prototype)))) {
         // The prototype is not marked, age the map.
         new_age = age - 1;
       } else {
         // The prototype and the constructor are marked, this map keeps only
         // transition tree alive, not JSObjects. Do not age the map.
         new_age = age;
       }
     } else {
       new_age = FLAG_retain_maps_for_n_gc;
     }
@@ skipping 86 matching lines @@
     // Only pointers to from space have to be updated.
     if (heap_->InFromSpace(obj)) {
       MapWord map_word = obj->map_word();
       // There may be objects on the marking deque that do not exist anymore,
       // e.g. left trimmed objects or objects from the root set (frames).
       // If these object are dead at scavenging time, their marking deque
       // entries will not point to forwarding addresses. Hence, we can discard
       // them.
       if (map_word.IsForwardingAddress()) {
         HeapObject* dest = map_word.ToForwardingAddress();
-        if (ObjectMarking::IsBlack(dest)) continue;
+        if (Marking::IsBlack(ObjectMarking::MarkBitFrom(dest))) continue;
         array[new_top] = dest;
         new_top = ((new_top + 1) & mask);
         DCHECK(new_top != marking_deque->bottom());
-        DCHECK(ObjectMarking::IsGrey(obj) ||
-               (obj->IsFiller() && ObjectMarking::IsWhite(obj)));
+#ifdef DEBUG
+        MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
+        DCHECK(Marking::IsGrey(mark_bit) ||
+               (obj->IsFiller() && Marking::IsWhite(mark_bit)));
+#endif
       }
     } else if (obj->map() != filler_map) {
       // Skip one word filler objects that appear on the
       // stack when we perform in place array shift.
       array[new_top] = obj;
       new_top = ((new_top + 1) & mask);
       DCHECK(new_top != marking_deque->bottom());
-      DCHECK(ObjectMarking::IsGrey(obj) ||
-             (obj->IsFiller() && ObjectMarking::IsWhite(obj)) ||
-             (MemoryChunk::FromAddress(obj->address())
-                  ->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
-              ObjectMarking::IsBlack(obj)));
+#ifdef DEBUG
+      MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
+      MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
+      DCHECK(Marking::IsGrey(mark_bit) ||
+             (obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
+             (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
+              Marking::IsBlack(mark_bit)));
+#endif
     }
   }
   marking_deque->set_top(new_top);
 }
 
 
 void IncrementalMarking::VisitObject(Map* map, HeapObject* obj, int size) {
   MarkGrey(heap_, map);
 
   IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
 
 #if ENABLE_SLOW_DCHECKS
   MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
   MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
   SLOW_DCHECK(Marking::IsGrey(mark_bit) ||
               (obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
               (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
                Marking::IsBlack(mark_bit)));
 #endif
   MarkBlack(obj, size);
 }
 
 void IncrementalMarking::MarkGrey(Heap* heap, HeapObject* object) {
-  if (ObjectMarking::IsWhite(object)) {
-    heap->incremental_marking()->WhiteToGreyAndPush(object);
+  MarkBit mark_bit = ObjectMarking::MarkBitFrom(object);
+  if (Marking::IsWhite(mark_bit)) {
+    heap->incremental_marking()->WhiteToGreyAndPush(object, mark_bit);
   }
 }
 
 void IncrementalMarking::MarkBlack(HeapObject* obj, int size) {
-  if (ObjectMarking::IsBlack(obj)) return;
-  ObjectMarking::GreyToBlack(obj);
+  MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
+  if (Marking::IsBlack(mark_bit)) return;
+  Marking::GreyToBlack(mark_bit);
+  MemoryChunk::IncrementLiveBytes(obj, size);
 }
 
 intptr_t IncrementalMarking::ProcessMarkingDeque(
     intptr_t bytes_to_process, ForceCompletionAction completion) {
   intptr_t bytes_processed = 0;
   MarkingDeque* marking_deque =
       heap_->mark_compact_collector()->marking_deque();
   while (!marking_deque->IsEmpty() && (bytes_processed < bytes_to_process ||
                                        completion == FORCE_COMPLETION)) {
     HeapObject* obj = marking_deque->Pop();
 
     // Left trimming may result in white filler objects on the marking deque.
     // Ignore these objects.
     if (obj->IsFiller()) {
-      DCHECK(ObjectMarking::IsImpossible(obj) || ObjectMarking::IsWhite(obj));
+      DCHECK(Marking::IsImpossible(ObjectMarking::MarkBitFrom(obj)) ||
+             Marking::IsWhite(ObjectMarking::MarkBitFrom(obj)));
       continue;
     }
 
     Map* map = obj->map();
     int size = obj->SizeFromMap(map);
     unscanned_bytes_of_large_object_ = 0;
     VisitObject(map, obj, size);
     bytes_processed += size - unscanned_bytes_of_large_object_;
   }
   // Report all found wrappers to the embedder. This is necessary as the
@@ skipping 34 matching lines @@
     }
   }
 
   Object* context = heap_->native_contexts_list();
   while (!context->IsUndefined(heap_->isolate())) {
     // GC can happen when the context is not fully initialized,
     // so the cache can be undefined.
     HeapObject* cache = HeapObject::cast(
         Context::cast(context)->get(Context::NORMALIZED_MAP_CACHE_INDEX));
     if (!cache->IsUndefined(heap_->isolate())) {
-      if (ObjectMarking::IsGrey(cache)) {
-        ObjectMarking::GreyToBlack(cache);
+      MarkBit mark_bit = ObjectMarking::MarkBitFrom(cache);
+      if (Marking::IsGrey(mark_bit)) {
+        Marking::GreyToBlack(mark_bit);
+        MemoryChunk::IncrementLiveBytes(cache, cache->Size());
       }
     }
     context = Context::cast(context)->next_context_link();
   }
 }
 
 
 void IncrementalMarking::Stop() {
   if (IsStopped()) return;
   if (FLAG_trace_incremental_marking) {
@@ skipping 260 matching lines @@
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 
 }  // namespace internal
 }  // namespace v8