Oilpan: Replace GCStates with GCPhase

Replaces the following GCStates with GCPhase counterparts.
- kGCRunning
- kSweeping
- kSweepingAndIdleGCScheduled
- kSweepingAndPreciseGCScheduled

Bug: 757440
Change-Id: I92b40d326bbedfe66ce41aca7d563968eaf3b28a
Reviewed-on: https://chromium-review.googlesource.com/980412
Commit-Queue: Keishi Hattori <keishi@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#546092}

third_party/WebKit/Source/bindings/core/v8/V8GCController.cpp

@@ -266,7 +266,6 @@ void V8GCController::GcEpilogue(v8::Isolate* isolate,
           BlinkGC::kEagerSweeping, BlinkGC::kForcedGC);
 
       // Forces a precise GC at the end of the current event loop.
-      CHECK(!current_thread_state->IsInGC());
       current_thread_state->SetGCState(ThreadState::kFullGCScheduled);
     }
 

third_party/WebKit/Source/platform/heap/Heap.cpp

@@ -162,7 +162,7 @@ ThreadHeap::~ThreadHeap() {
 
 Address ThreadHeap::CheckAndMarkPointer(MarkingVisitor* visitor,
                                         Address address) {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
 
 #if !DCHECK_IS_ON()
   if (heap_does_not_contain_cache_->Lookup(address))
@@ -196,7 +196,7 @@ Address ThreadHeap::CheckAndMarkPointer(
     MarkingVisitor* visitor,
     Address address,
     MarkedPointerCallbackForTesting callback) {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
 
   if (BasePage* page = LookupPageForAddress(address)) {
     DCHECK(page->Contains(address));
@@ -213,7 +213,7 @@ Address ThreadHeap::CheckAndMarkPointer(
 
 void ThreadHeap::RegisterWeakTable(void* table,
                                    EphemeronCallback iteration_callback) {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
 #if DCHECK_IS_ON()
   auto result = ephemeron_callbacks_.insert(table, iteration_callback);
   DCHECK(result.is_new_entry ||
@@ -451,18 +451,16 @@ void ThreadHeap::ReportMemoryUsageForTracing() {
 }
 
 size_t ThreadHeap::ObjectPayloadSizeForTesting() {
+  ThreadState::AtomicPauseScope atomic_pause_scope(thread_state_);
   size_t object_payload_size = 0;
   thread_state_->SetGCPhase(ThreadState::GCPhase::kMarking);
-  thread_state_->SetGCState(ThreadState::kGCRunning);
   thread_state_->Heap().MakeConsistentForGC();
   thread_state_->Heap().PrepareForSweep();
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i)
     object_payload_size += arenas_[i]->ObjectPayloadSizeForTesting();
   MakeConsistentForMutator();
   thread_state_->SetGCPhase(ThreadState::GCPhase::kSweeping);
-  thread_state_->SetGCState(ThreadState::kSweeping);
   thread_state_->SetGCPhase(ThreadState::GCPhase::kNone);
-  thread_state_->SetGCState(ThreadState::kNoGCScheduled);
   return object_payload_size;
 }
 
@@ -487,19 +485,19 @@ bool ThreadHeap::IsAddressInHeapDoesNotContainCache(Address address) {
 }
 
 void ThreadHeap::VisitPersistentRoots(Visitor* visitor) {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
   TRACE_EVENT0("blink_gc", "ThreadHeap::visitPersistentRoots");
   thread_state_->VisitPersistents(visitor);
 }
 
 void ThreadHeap::VisitStackRoots(MarkingVisitor* visitor) {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
   TRACE_EVENT0("blink_gc", "ThreadHeap::visitStackRoots");
   thread_state_->VisitStack(visitor);
 }
 
 BasePage* ThreadHeap::LookupPageForAddress(Address address) {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
   if (PageMemoryRegion* region = region_tree_->Lookup(address)) {
     return region->PageFromAddress(address);
   }
@@ -507,7 +505,7 @@ BasePage* ThreadHeap::LookupPageForAddress(Address address) {
 }
 
 void ThreadHeap::ResetHeapCounters() {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
 
   ThreadHeap::ReportMemoryUsageForTracing();
 
@@ -518,14 +516,14 @@ void ThreadHeap::ResetHeapCounters() {
 }
 
 void ThreadHeap::MakeConsistentForGC() {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
   TRACE_EVENT0("blink_gc", "ThreadHeap::MakeConsistentForGC");
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i)
     arenas_[i]->MakeConsistentForGC();
 }
 
 void ThreadHeap::MakeConsistentForMutator() {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
   for (int i = 0; i < BlinkGC::kNumberOfArenas; ++i)
     arenas_[i]->MakeConsistentForMutator();
 }
@@ -555,7 +553,7 @@ void ThreadHeap::Compact() {
 }
 
 void ThreadHeap::PrepareForSweep() {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
   DCHECK(thread_state_->CheckThread());
   for (int i = 0; i < BlinkGC::kNumberOfArenas; i++)
     arenas_[i]->PrepareForSweep();
@@ -659,7 +657,7 @@ BasePage* ThreadHeap::FindPageFromAddress(Address address) {
 #endif
 
 void ThreadHeap::TakeSnapshot(SnapshotType type) {
-  DCHECK(thread_state_->IsInGC());
+  DCHECK(thread_state_->InAtomicMarkingPause());
 
   // 0 is used as index for freelist entries. Objects are indexed 1 to
   // gcInfoIndex.

third_party/WebKit/Source/platform/heap/HeapAllocator.cpp

@@ -13,7 +13,7 @@ void HeapAllocator::BackingFree(void* address) {
   ThreadState* state = ThreadState::Current();
   if (state->SweepForbidden())
     return;
-  DCHECK(!state->IsInGC());
+  DCHECK(!state->in_atomic_pause());
 
   // Don't promptly free large objects because their page is never reused.
   // Don't free backings allocated on other threads.
@@ -41,8 +41,7 @@ void HeapAllocator::FreeInlineVectorBacking(void* address) {
 }
 
 void HeapAllocator::FreeHashTableBacking(void* address, bool is_weak_table) {
-  if (!ThreadState::Current()->IsIncrementalMarkingInProgress() ||
-      !is_weak_table)
+  if (!ThreadState::Current()->IsMarkingInProgress() || !is_weak_table)
     BackingFree(address);
 }
 
@@ -53,7 +52,7 @@ bool HeapAllocator::BackingExpand(void* address, size_t new_size) {
   ThreadState* state = ThreadState::Current();
   if (state->SweepForbidden())
     return false;
-  DCHECK(!state->IsInGC());
+  DCHECK(!state->in_atomic_pause());
   DCHECK(state->IsAllocationAllowed());
   DCHECK_EQ(&state->Heap(), &ThreadState::FromObject(address)->Heap());
 
@@ -94,7 +93,7 @@ bool HeapAllocator::BackingShrink(void* address,
   ThreadState* state = ThreadState::Current();
   if (state->SweepForbidden())
     return false;
-  DCHECK(!state->IsInGC());
+  DCHECK(!state->in_atomic_pause());
   DCHECK(state->IsAllocationAllowed());
   DCHECK_EQ(&state->Heap(), &ThreadState::FromObject(address)->Heap());
 

third_party/WebKit/Source/platform/heap/HeapPage.cpp

@@ -226,7 +226,7 @@ size_t BaseArena::ObjectPayloadSizeForTesting() {
 }
 
 void BaseArena::PrepareForSweep() {
-  DCHECK(GetThreadState()->IsInGC());
+  DCHECK(GetThreadState()->InAtomicMarkingPause());
   DCHECK(SweepingCompleted());
 
   ClearFreeLists();
@@ -1791,7 +1791,7 @@ size_t HeapDoesNotContainCache::GetHash(Address address) {
 }
 
 bool HeapDoesNotContainCache::Lookup(Address address) {
-  DCHECK(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->InAtomicMarkingPause());
 
   size_t index = GetHash(address);
   DCHECK(!(index & 1));
@@ -1804,7 +1804,7 @@ bool HeapDoesNotContainCache::Lookup(Address address) {
 }
 
 void HeapDoesNotContainCache::AddEntry(Address address) {
-  DCHECK(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->InAtomicMarkingPause());
 
   has_entries_ = true;
   size_t index = GetHash(address);

third_party/WebKit/Source/platform/heap/MarkingVisitor.h

@@ -147,7 +147,7 @@ class PLATFORM_EXPORT MarkingVisitor final : public Visitor {
 
 inline bool MarkingVisitor::MarkHeaderNoTracing(HeapObjectHeader* header) {
   DCHECK(header);
-  DCHECK(State()->IsInGC() || State()->IsIncrementalMarking());
+  DCHECK(State()->InAtomicMarkingPause() || State()->IsIncrementalMarking());
   // A GC should only mark the objects that belong in its heap.
   DCHECK_EQ(State(),
             PageFromObject(header->Payload())->Arena()->GetThreadState());

third_party/WebKit/Source/platform/heap/ThreadState.cpp

@@ -418,7 +418,7 @@ bool ThreadState::ShouldScheduleIncrementalMarking() const {
 #if BUILDFLAG(BLINK_HEAP_INCREMENTAL_MARKING)
   // TODO(mlippautz): For now immediately schedule incremental marking if
   // the runtime flag is provided, basically exercising a stress test.
-  return (GcState() == kNoGCScheduled || GcState() == kSweeping) &&
+  return GcState() == kNoGCScheduled &&
          RuntimeEnabledFeatures::HeapIncrementalMarkingEnabled();
 #else
   return false;
@@ -685,18 +685,19 @@ void ThreadState::ScheduleIncrementalMarkingFinalize() {
 }
 
 void ThreadState::ScheduleIdleGC() {
-  if (IsSweepingInProgress()) {
-    SetGCState(kSweepingAndIdleGCScheduled);
+  SetGCState(kIdleGCScheduled);
+  if (IsSweepingInProgress())
     return;
-  }
-
   // Some threads (e.g. PPAPI thread) don't have a scheduler.
-  if (!Platform::Current()->CurrentThread()->Scheduler())
+  // Also some tests can call Platform::SetCurrentPlatformForTesting() at any
+  // time, so we need to check for the scheduler here instead of
+  // ScheduleIdleGC().
+  if (!Platform::Current()->CurrentThread()->Scheduler()) {
+    SetGCState(kNoGCScheduled);
     return;
-
+  }
   Platform::Current()->CurrentThread()->Scheduler()->PostNonNestableIdleTask(
       FROM_HERE, WTF::Bind(&ThreadState::PerformIdleGC, WTF::Unretained(this)));
-  SetGCState(kIdleGCScheduled);
 }
 
 void ThreadState::ScheduleIdleLazySweep() {
@@ -711,11 +712,6 @@ void ThreadState::ScheduleIdleLazySweep() {
 
 void ThreadState::SchedulePreciseGC() {
   DCHECK(CheckThread());
-  if (IsSweepingInProgress()) {
-    SetGCState(kSweepingAndPreciseGCScheduled);
-    return;
-  }
-
   SetGCState(kPreciseGCScheduled);
 }
 
@@ -732,10 +728,6 @@ void UnexpectedGCState(ThreadState::GCState gc_state) {
     UNEXPECTED_GCSTATE(kIdleGCScheduled);
     UNEXPECTED_GCSTATE(kPreciseGCScheduled);
     UNEXPECTED_GCSTATE(kFullGCScheduled);
-    UNEXPECTED_GCSTATE(kGCRunning);
-    UNEXPECTED_GCSTATE(kSweeping);
-    UNEXPECTED_GCSTATE(kSweepingAndIdleGCScheduled);
-    UNEXPECTED_GCSTATE(kSweepingAndPreciseGCScheduled);
     UNEXPECTED_GCSTATE(kIncrementalMarkingStartScheduled);
     UNEXPECTED_GCSTATE(kIncrementalMarkingStepScheduled);
     UNEXPECTED_GCSTATE(kIncrementalMarkingFinalizeScheduled);
@@ -756,13 +748,14 @@ void ThreadState::SetGCState(GCState gc_state) {
     case kNoGCScheduled:
       DCHECK(CheckThread());
       VERIFY_STATE_TRANSITION(
-          gc_state_ == kSweeping || gc_state_ == kSweepingAndIdleGCScheduled ||
+          gc_state_ == kNoGCScheduled || gc_state_ == kIdleGCScheduled ||
+          gc_state_ == kPreciseGCScheduled || gc_state_ == kFullGCScheduled ||
+          gc_state_ == kPageNavigationGCScheduled ||
           gc_state_ == kIncrementalMarkingFinalizeScheduled);
       break;
     case kIncrementalMarkingStartScheduled:
       DCHECK(CheckThread());
-      VERIFY_STATE_TRANSITION((gc_state_ == kSweeping) ||
-                              (gc_state_ == kNoGCScheduled));
+      VERIFY_STATE_TRANSITION(gc_state_ == kNoGCScheduled);
       break;
     case kIncrementalMarkingStepScheduled:
       DCHECK(CheckThread());
@@ -773,35 +766,20 @@ void ThreadState::SetGCState(GCState gc_state) {
       DCHECK(CheckThread());
       VERIFY_STATE_TRANSITION(gc_state_ == kIncrementalMarkingStepScheduled);
       break;
-    case kIdleGCScheduled:
-    case kPreciseGCScheduled:
     case kFullGCScheduled:
     case kPageNavigationGCScheduled:
+      // These GCs should not be scheduled while sweeping is in progress.
+      DCHECK(!IsSweepingInProgress());
+      FALLTHROUGH;
+    case kIdleGCScheduled:
+    case kPreciseGCScheduled:
       DCHECK(CheckThread());
       VERIFY_STATE_TRANSITION(
           gc_state_ == kNoGCScheduled || gc_state_ == kIdleGCScheduled ||
           gc_state_ == kPreciseGCScheduled || gc_state_ == kFullGCScheduled ||
-          gc_state_ == kPageNavigationGCScheduled || gc_state_ == kSweeping ||
-          gc_state_ == kSweepingAndIdleGCScheduled ||
-          gc_state_ == kSweepingAndPreciseGCScheduled);
+          gc_state_ == kPageNavigationGCScheduled);
       CompleteSweep();
       break;
-    case kGCRunning:
-      DCHECK(!IsInGC());
-      VERIFY_STATE_TRANSITION(gc_state_ != kGCRunning);
-      break;
-    case kSweeping:
-      DCHECK(IsInGC());
-      DCHECK(CheckThread());
-      VERIFY_STATE_TRANSITION(gc_state_ == kGCRunning);
-      break;
-    case kSweepingAndIdleGCScheduled:
-    case kSweepingAndPreciseGCScheduled:
-      DCHECK(CheckThread());
-      VERIFY_STATE_TRANSITION(gc_state_ == kSweeping ||
-                              gc_state_ == kSweepingAndIdleGCScheduled ||
-                              gc_state_ == kSweepingAndPreciseGCScheduled);
-      break;
     default:
       NOTREACHED();
   }
@@ -869,7 +847,7 @@ void ThreadState::RunScheduledGC(BlinkGC::StackState stack_state) {
 
 void ThreadState::PreSweep(BlinkGC::MarkingType marking_type,
                            BlinkGC::SweepingType sweeping_type) {
-  DCHECK(IsInGC());
+  DCHECK(InAtomicMarkingPause());
   DCHECK(CheckThread());
   Heap().PrepareForSweep();
 
@@ -892,9 +870,8 @@ void ThreadState::PreSweep(BlinkGC::MarkingType marking_type,
     return;
   }
 
-  // We have to set the GCState to Sweeping before calling pre-finalizers
+  // We have to set the GCPhase to Sweeping before calling pre-finalizers
   // to disallow a GC during the pre-finalizers.
-  SetGCState(kSweeping);
   SetGCPhase(GCPhase::kSweeping);
 
   // Allocation is allowed during the pre-finalizers and destructors.
@@ -1040,20 +1017,8 @@ void ThreadState::PostSweep() {
   }
 
   SetGCPhase(GCPhase::kNone);
-  switch (GcState()) {
-    case kSweeping:
-      SetGCState(kNoGCScheduled);
-      break;
-    case kSweepingAndPreciseGCScheduled:
-      SetGCState(kPreciseGCScheduled);
-      break;
-    case kSweepingAndIdleGCScheduled:
-      SetGCState(kNoGCScheduled);
-      ScheduleIdleGC();
-      break;
-    default:
-      NOTREACHED();
-  }
+  if (GcState() == kIdleGCScheduled)
+    ScheduleIdleGC();
 
   gc_age_++;
 
@@ -1301,6 +1266,8 @@ void ThreadState::CollectGarbage(BlinkGC::StackState stack_state,
   RUNTIME_CALL_TIMER_SCOPE_IF_ISOLATE_EXISTS(
       GetIsolate(), RuntimeCallStats::CounterId::kCollectGarbage);
 
+  SetGCState(kNoGCScheduled);
+
   {
     AtomicPauseScope atomic_pause_scope(this);
     {
@@ -1384,8 +1351,7 @@ void ThreadState::MarkPhasePrologue(BlinkGC::StackState stack_state,
   if (isolate_ && perform_cleanup_)
     perform_cleanup_(isolate_);
 
-  DCHECK(!IsInGC());
-  SetGCState(kGCRunning);
+  DCHECK(InAtomicMarkingPause());
   Heap().MakeConsistentForGC();
   Heap().FlushHeapDoesNotContainCacheIfNeeded();
   Heap().ClearArenaAges();

third_party/WebKit/Source/platform/heap/ThreadState.h

@@ -150,10 +150,6 @@ class PLATFORM_EXPORT ThreadState {
     kPreciseGCScheduled,
     kFullGCScheduled,
     kPageNavigationGCScheduled,
-    kGCRunning,
-    kSweeping,
-    kSweepingAndIdleGCScheduled,
-    kSweepingAndPreciseGCScheduled,
   };
 
   // The phase that the GC is in. The GCPhase will not return kNone for mutators
@@ -263,17 +259,13 @@ class PLATFORM_EXPORT ThreadState {
   void SchedulePageNavigationGCIfNeeded(float estimated_removal_ratio);
   void SchedulePageNavigationGC();
   void ScheduleGCIfNeeded();
+  void PostIdleGCTask();
   void WillStartV8GC(BlinkGC::V8GCType);
   void SetGCState(GCState);
   GCState GcState() const { return gc_state_; }
   void SetGCPhase(GCPhase);
-  bool IsInGC() const { return GcState() == kGCRunning; }
   bool IsMarkingInProgress() const { return gc_phase_ == GCPhase::kMarking; }
-  bool IsSweepingInProgress() const {
-    return GcState() == kSweeping ||
-           GcState() == kSweepingAndPreciseGCScheduled ||
-           GcState() == kSweepingAndIdleGCScheduled;
-  }
+  bool IsSweepingInProgress() const { return gc_phase_ == GCPhase::kSweeping; }
 
   // Incremental GC.
 
@@ -285,11 +277,6 @@ class PLATFORM_EXPORT ThreadState {
   void IncrementalMarkingStep();
   void IncrementalMarkingFinalize();
 
-  bool IsIncrementalMarkingInProgress() const {
-    return GcState() == kIncrementalMarkingStepScheduled ||
-           GcState() == kIncrementalMarkingFinalizeScheduled;
-  }
-
   // A GC runs in the following sequence.
   //
   // 1) preGC() is called.
@@ -300,12 +287,6 @@ class PLATFORM_EXPORT ThreadState {
   // 4) Lazy sweeping sweeps heaps incrementally. completeSweep() may be called
   //    to complete the sweeping.
   // 5) postSweep() is called.
-  //
-  // Notes:
-  // - The world is stopped between 1) and 3).
-  // - isInGC() returns true between 1) and 3).
-  // - isSweepingInProgress() returns true while any sweeping operation is
-  //   running.
   void MarkPhasePrologue(BlinkGC::StackState,
                          BlinkGC::MarkingType,
                          BlinkGC::GCReason);