[heap] Remove obsolete was_marked_incrementally field.

src/heap/mark-compact.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/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 27 matching lines @@
 MarkCompactCollector::MarkCompactCollector(Heap* heap)
     :  // NOLINT
 #ifdef DEBUG
       state_(IDLE),
 #endif
       reduce_memory_footprint_(false),
       abort_incremental_marking_(false),
       finalize_incremental_marking_(false),
       marking_parity_(ODD_MARKING_PARITY),
       compacting_(false),
-      was_marked_incrementally_(false),
       sweeping_in_progress_(false),
       pending_sweeper_jobs_semaphore_(0),
       evacuation_(false),
       migration_slots_buffer_(NULL),
       heap_(heap),
       marking_deque_memory_(NULL),
       marking_deque_memory_committed_(0),
       code_flusher_(NULL),
       have_code_to_deoptimize_(false) {
 }
@@ skipping 272 matching lines @@
     SlotsBuffer::VerifySlots(heap, chunk->slots_buffer());
   }
 }
 #endif
 
 
 void MarkCompactCollector::CollectGarbage() {
   // Make sure that Prepare() has been called. The individual steps below will
   // update the state as they proceed.
   DCHECK(state_ == PREPARE_GC);
+  DCHECK(heap_->incremental_marking()->IsStopped());
 
   MarkLiveObjects();
 
-  DCHECK(heap_->incremental_marking()->IsStopped());
-
   // ClearNonLiveReferences can deoptimize code in dependent code arrays.
   // Process weak cells before so that weak cells in dependent code
   // arrays are cleared or contain only live code objects.
   ProcessAndClearWeakCells();
 
   ClearNonLiveReferences();
 
   ClearWeakCollections();
 
   heap_->set_encountered_weak_cells(Smi::FromInt(0));
@@ skipping 424 matching lines @@
     }
     compacting_ = false;
     evacuation_candidates_.Rewind(0);
     invalidated_code_.Rewind(0);
   }
   DCHECK_EQ(0, evacuation_candidates_.length());
 }
 
 
 void MarkCompactCollector::Prepare() {
-  was_marked_incrementally_ = heap()->incremental_marking()->IsMarking();
+  bool was_marked_incrementally = heap()->incremental_marking()->IsMarking();
 
 #ifdef DEBUG
   DCHECK(state_ == IDLE);
   state_ = PREPARE_GC;
 #endif
 
   DCHECK(!FLAG_never_compact || !FLAG_always_compact);
 
   if (sweeping_in_progress()) {
     // Instead of waiting we could also abort the sweeper threads here.
     EnsureSweepingCompleted();
   }
 
   // Clear marking bits if incremental marking is aborted.
-  if (was_marked_incrementally_ && abort_incremental_marking_) {
+  if (was_marked_incrementally && abort_incremental_marking_) {
     heap()->incremental_marking()->Stop();
     ClearMarkbits();
     AbortWeakCollections();
     AbortWeakCells();
     AbortCompaction();
-    was_marked_incrementally_ = false;
+    was_marked_incrementally = false;
+  }
+
+  if (was_marked_incrementally) {
+    heap()->incremental_marking()->Finalize();
+  } else {
+    // Abort any pending incremental activities e.g. incremental sweeping.
+    heap()->incremental_marking()->Stop();

[Hannes Payer (out of office), 2015/08/07 10:53:38]

in that case, stop was already performed before.

+    if (marking_deque_.in_use()) {
+      marking_deque_.Uninitialize(true);

[Hannes Payer (out of office), 2015/08/07 10:53:38]

Why are we doing this just in this case?

+    }
   }
 
   // Don't start compaction if we are in the middle of incremental
   // marking cycle. We did not collect any slots.
-  if (!FLAG_never_compact && !was_marked_incrementally_) {
+  if (!FLAG_never_compact && !was_marked_incrementally) {
     StartCompaction(NON_INCREMENTAL_COMPACTION);
   }
 
   PagedSpaces spaces(heap());
   for (PagedSpace* space = spaces.next(); space != NULL;
        space = spaces.next()) {
     space->PrepareForMarkCompact();
   }
 
 #ifdef VERIFY_HEAP
-  if (!was_marked_incrementally_ && FLAG_verify_heap) {
+  if (!was_marked_incrementally && FLAG_verify_heap) {
     VerifyMarkbitsAreClean();
   }
 #endif
 }
 
 
 void MarkCompactCollector::Finish() {
 #ifdef DEBUG
   DCHECK(state_ == SWEEP_SPACES || state_ == RELOCATE_OBJECTS);
   state_ = IDLE;
@@ skipping 1392 matching lines @@
   GCTracer::Scope gc_scope(heap()->tracer(), GCTracer::Scope::MC_MARK);
   double start_time = 0.0;
   if (FLAG_print_cumulative_gc_stat) {
     start_time = base::OS::TimeCurrentMillis();
   }
   // The recursive GC marker detects when it is nearing stack overflow,
   // and switches to a different marking system.  JS interrupts interfere
   // with the C stack limit check.
   PostponeInterruptsScope postpone(isolate());
 
-  IncrementalMarking* incremental_marking = heap_->incremental_marking();
-  if (was_marked_incrementally_) {
-    incremental_marking->Finalize();
-  } else {
-    // Abort any pending incremental activities e.g. incremental sweeping.
-    incremental_marking->Stop();
-    if (marking_deque_.in_use()) {
-      marking_deque_.Uninitialize(true);
-    }
-  }
-
 #ifdef DEBUG
   DCHECK(state_ == PREPARE_GC);
   state_ = MARK_LIVE_OBJECTS;
 #endif
 
   EnsureMarkingDequeIsCommittedAndInitialize(
       MarkCompactCollector::kMaxMarkingDequeSize);
 
   PrepareForCodeFlushing();
 
@@ skipping 1423 matching lines @@
 
   {
     GCTracer::Scope gc_scope(heap()->tracer(),
                              GCTracer::Scope::MC_UPDATE_POINTERS_TO_EVACUATED);
     SlotsBuffer::UpdateSlotsRecordedIn(heap_, migration_slots_buffer_);
     if (FLAG_trace_fragmentation_verbose) {
       PrintF("  migration slots buffer: %d\n",
              SlotsBuffer::SizeOfChain(migration_slots_buffer_));
     }
 
-    if (compacting_ && was_marked_incrementally_) {
+    if (compacting_ && heap()->incremental_marking()->IsMarking()) {
       GCTracer::Scope gc_scope(heap()->tracer(),
                                GCTracer::Scope::MC_RESCAN_LARGE_OBJECTS);
       // It's difficult to filter out slots recorded for large objects.
       LargeObjectIterator it(heap_->lo_space());
       for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
         // LargeObjectSpace is not swept yet thus we have to skip
         // dead objects explicitly.
         if (!IsMarked(obj)) continue;
 
         Page* p = Page::FromAddress(obj->address());
@@ skipping 1070 matching lines @@
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 }  // namespace internal
 }  // namespace v8