Revert 12609 (Allow partial scanning of large arrays)

src/incremental-marking.cc

 // Copyright 2012 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 174 matching lines @@
     Heap* heap = map->GetHeap();
     SharedFunctionInfo* shared = SharedFunctionInfo::cast(object);
     if (shared->ic_age() != heap->global_ic_age()) {
       shared->ResetForNewContext(heap->global_ic_age());
     }
     FixedBodyVisitor<IncrementalMarkingMarkingVisitor,
                      SharedFunctionInfo::BodyDescriptor,
                      void>::Visit(map, object);
   }
 
-  static const int kScanningChunk = 32 * 1024;
-
-  static int VisitHugeArray(FixedArray* array) {
-    Heap* heap = array->GetHeap();
-    MemoryChunk* chunk = MemoryChunk::FromAddress(array->address());
-    Object** start = array->data_start();
-    int length = array->length();
-
-    if (chunk->owner()->identity() != LO_SPACE) {
-      VisitPointers(heap, start, start + length);
-      return length;
-    }
-
-    int from =
-        chunk->IsPartiallyScanned() ? chunk->PartiallyScannedProgress() : 0;
-    int to = Min(from + kScanningChunk, length);
-
-    VisitPointers(heap, start + from, start + to);
-
-    if (to == length) {
-      // If it went from black to grey while it was waiting for the next bit to
-      // be scanned then we have to start the scan again.
-      MarkBit mark_bit = Marking::MarkBitFrom(array);
-      if (!Marking::IsBlack(mark_bit)) {
-        ASSERT(Marking::IsGrey(mark_bit));
-        chunk->SetPartiallyScannedProgress(0);
-      } else {
-        chunk->SetCompletelyScanned();
-      }
-    } else {
-      chunk->SetPartiallyScannedProgress(to);
-    }
-    return to - from;
-  }
-
   static inline void VisitJSFunction(Map* map, HeapObject* object) {
     Heap* heap = map->GetHeap();
     // Iterate over all fields in the body but take care in dealing with
     // the code entry and skip weak fields.
     VisitPointers(heap,
                   HeapObject::RawField(object, JSFunction::kPropertiesOffset),
                   HeapObject::RawField(object, JSFunction::kCodeEntryOffset));
     VisitCodeEntry(heap, object->address() + JSFunction::kCodeEntryOffset);
     VisitPointers(heap,
                   HeapObject::RawField(object,
@@ skipping 409 matching lines @@
       }
     } 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);
       ASSERT(new_top != marking_deque_.bottom());
 #ifdef DEBUG
         MarkBit mark_bit = Marking::MarkBitFrom(obj);
         ASSERT(Marking::IsGrey(mark_bit) ||
-               (obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
-               MemoryChunk::FromAddress(obj->address())->IsPartiallyScanned());
+               (obj->IsFiller() && Marking::IsWhite(mark_bit)));
 #endif
     }
   }
   marking_deque_.set_top(new_top);
 
   steps_took_since_last_gc_ = 0;
   steps_count_since_last_gc_ = 0;
   longest_step_ = 0.0;
 }
 
 
 void IncrementalMarking::Hurry() {
   if (state() == MARKING) {
     double start = 0.0;
     if (FLAG_trace_incremental_marking) {
       PrintF("[IncrementalMarking] Hurry\n");
       start = OS::TimeCurrentMillis();
     }
     // TODO(gc) hurry can mark objects it encounters black as mutator
     // was stopped.
     Map* filler_map = heap_->one_pointer_filler_map();
     Map* native_context_map = heap_->native_context_map();
-    do {
-      while (!marking_deque_.IsEmpty()) {
-        HeapObject* obj = marking_deque_.Pop();
+    while (!marking_deque_.IsEmpty()) {
+      HeapObject* obj = marking_deque_.Pop();
 
-        // Explicitly skip one word fillers. Incremental markbit patterns are
-        // correct only for objects that occupy at least two words.
-        Map* map = obj->map();
-        if (map == filler_map) {
-          continue;
-        } else if (map == native_context_map) {
-          // Native contexts have weak fields.
-          IncrementalMarkingMarkingVisitor::VisitNativeContext(map, obj);
-          ASSERT(!Marking::IsBlack(Marking::MarkBitFrom(obj)));
-          MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
-        } else if (map->instance_type() == FIXED_ARRAY_TYPE &&
-          FixedArray::cast(obj)->length() >
-                IncrementalMarkingMarkingVisitor::kScanningChunk) {
-          MarkBit map_mark_bit = Marking::MarkBitFrom(map);
-          if (Marking::IsWhite(map_mark_bit)) {
-            WhiteToGreyAndPush(map, map_mark_bit);
-          }
-          MarkBit mark_bit = Marking::MarkBitFrom(obj);
-          if (!Marking::IsBlack(mark_bit)) {
-            MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
-          } else {
-            ASSERT(
-                MemoryChunk::FromAddress(obj->address())->IsPartiallyScanned());
-          }
-          IncrementalMarkingMarkingVisitor::VisitHugeArray(
-                FixedArray::cast(obj));
-         } else {
-          MarkBit map_mark_bit = Marking::MarkBitFrom(map);
-          if (Marking::IsWhite(map_mark_bit)) {
-            WhiteToGreyAndPush(map, map_mark_bit);
-          }
-          IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
-          ASSERT(!Marking::IsBlack(Marking::MarkBitFrom(obj)));
-          MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
+      // Explicitly skip one word fillers. Incremental markbit patterns are
+      // correct only for objects that occupy at least two words.
+      Map* map = obj->map();
+      if (map == filler_map) {
+        continue;
+      } else if (map == native_context_map) {
+        // Native contexts have weak fields.
+        IncrementalMarkingMarkingVisitor::VisitNativeContext(map, obj);
+      } else {
+        MarkBit map_mark_bit = Marking::MarkBitFrom(map);
+        if (Marking::IsWhite(map_mark_bit)) {
+          WhiteToGreyAndPush(map, map_mark_bit);
         }
+        IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
+      }
 
-        MarkBit mark_bit = Marking::MarkBitFrom(obj);
-        Marking::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));
-      }
-      MarkCompactCollector::ProcessLargePostponedArrays(heap_, &marking_deque_);
-    } while (!marking_deque_.IsEmpty());
+      MarkBit mark_bit = Marking::MarkBitFrom(obj);
+      ASSERT(!Marking::IsBlack(mark_bit));
+      Marking::MarkBlack(mark_bit);
+      MemoryChunk::IncrementLiveBytesFromGC(obj->address(), obj->Size());
+    }
+    state_ = COMPLETE;
+    if (FLAG_trace_incremental_marking) {
+      double end = OS::TimeCurrentMillis();
+      PrintF("[IncrementalMarking] Complete (hurry), spent %d ms.\n",
+             static_cast<int>(end - start));
+    }
   }
 
   if (FLAG_cleanup_code_caches_at_gc) {
     PolymorphicCodeCache* poly_cache = heap_->polymorphic_code_cache();
     Marking::GreyToBlack(Marking::MarkBitFrom(poly_cache));
     MemoryChunk::IncrementLiveBytesFromGC(poly_cache->address(),
                                           PolymorphicCodeCache::kSize);
   }
 
   Object* context = heap_->native_contexts_list();
@@ skipping 100 matching lines @@
   }
 
   if (state_ == SWEEPING) {
     if (heap_->AdvanceSweepers(static_cast<int>(bytes_to_process))) {
       bytes_scanned_ = 0;
       StartMarking(PREVENT_COMPACTION);
     }
   } else if (state_ == MARKING) {
     Map* filler_map = heap_->one_pointer_filler_map();
     Map* native_context_map = heap_->native_context_map();
-    while (true) {
-      while (!marking_deque_.IsEmpty() && bytes_to_process > 0) {
-        HeapObject* obj = marking_deque_.Pop();
+    while (!marking_deque_.IsEmpty() && bytes_to_process > 0) {
+      HeapObject* obj = marking_deque_.Pop();
 
-        // Explicitly skip one word fillers. Incremental markbit patterns are
-        // correct only for objects that occupy at least two words.
-        Map* map = obj->map();
-        if (map == filler_map) continue;
+      // Explicitly skip one word fillers. Incremental markbit patterns are
+      // correct only for objects that occupy at least two words.
+      Map* map = obj->map();
+      if (map == filler_map) continue;
 
-        int size = obj->SizeFromMap(map);
-        MarkBit map_mark_bit = Marking::MarkBitFrom(map);
-        if (Marking::IsWhite(map_mark_bit)) {
-          WhiteToGreyAndPush(map, map_mark_bit);
-        }
+      int size = obj->SizeFromMap(map);
+      bytes_to_process -= size;
+      MarkBit map_mark_bit = Marking::MarkBitFrom(map);
+      if (Marking::IsWhite(map_mark_bit)) {
+        WhiteToGreyAndPush(map, map_mark_bit);
+      }
 
-        // TODO(gc) switch to static visitor instead of normal visitor.
-        if (map == native_context_map) {
-          // Native contexts have weak fields.
-          Context* ctx = Context::cast(obj);
+      // TODO(gc) switch to static visitor instead of normal visitor.
+      if (map == native_context_map) {
+        // Native contexts have weak fields.
+        Context* ctx = Context::cast(obj);
 
-          // We will mark cache black with a separate pass
-          // when we finish marking.
-          MarkObjectGreyDoNotEnqueue(ctx->normalized_map_cache());
+        // We will mark cache black with a separate pass
+        // when we finish marking.
+        MarkObjectGreyDoNotEnqueue(ctx->normalized_map_cache());
 
-          IncrementalMarkingMarkingVisitor::VisitNativeContext(map, ctx);
-          bytes_to_process -= size;
-          SLOW_ASSERT(Marking::IsGrey(Marking::MarkBitFrom(obj)));
-          MemoryChunk::IncrementLiveBytesFromGC(obj->address(), size);
-        } else if (map->instance_type() == FIXED_ARRAY_TYPE &&
-          FixedArray::cast(obj)->length() >
-              IncrementalMarkingMarkingVisitor::kScanningChunk) {
-          SLOW_ASSERT(
-              Marking::IsGrey(Marking::MarkBitFrom(obj)) ||
-              MemoryChunk::FromAddress(obj->address())->IsPartiallyScanned());
-          bytes_to_process -=
-              IncrementalMarkingMarkingVisitor::VisitHugeArray(
-                  FixedArray::cast(obj));
-          MarkBit obj_mark_bit = Marking::MarkBitFrom(obj);
-          if (!Marking::IsBlack(obj_mark_bit)) {
-            MemoryChunk::IncrementLiveBytesFromGC(obj->address(), size);
-          }
-         } else {
-          IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
-          bytes_to_process -= size;
-          SLOW_ASSERT(
-              Marking::IsGrey(Marking::MarkBitFrom(obj)) ||
-              (obj->IsFiller() && Marking::IsWhite(Marking::MarkBitFrom(obj))));
-          MemoryChunk::IncrementLiveBytesFromGC(obj->address(), size);
-        }
+        IncrementalMarkingMarkingVisitor::VisitNativeContext(map, ctx);
+      } else {
+        IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
+      }
 
-        MarkBit obj_mark_bit = Marking::MarkBitFrom(obj);
-        Marking::MarkBlack(obj_mark_bit);
-      }
-      if (marking_deque_.IsEmpty()) {
-        MarkCompactCollector::ProcessLargePostponedArrays(heap_,
-                                                          &marking_deque_);
-        if (marking_deque_.IsEmpty()) {
-          MarkingComplete(action);
-          break;
-         }
-       } else {
-        ASSERT(bytes_to_process <= 0);
-        break;
-       }
+      MarkBit obj_mark_bit = Marking::MarkBitFrom(obj);
+      SLOW_ASSERT(Marking::IsGrey(obj_mark_bit) ||
+                  (obj->IsFiller() && Marking::IsWhite(obj_mark_bit)));
+      Marking::MarkBlack(obj_mark_bit);
+      MemoryChunk::IncrementLiveBytesFromGC(obj->address(), size);
     }
+    if (marking_deque_.IsEmpty()) MarkingComplete(action);
   }
 
   allocated_ = 0;
 
   steps_count_++;
   steps_count_since_last_gc_++;
 
   bool speed_up = false;
 
   if ((steps_count_ % kAllocationMarkingFactorSpeedupInterval) == 0) {
@@ skipping 81 matching lines @@
   allocation_marking_factor_ = kInitialAllocationMarkingFactor;
   bytes_scanned_ = 0;
 }
 
 
 int64_t IncrementalMarking::SpaceLeftInOldSpace() {
   return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
 }
 
 } }  // namespace v8::internal