Oilpan: Introduce a state transition model for Oilpan GC states

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 409 matching lines @@
         TRACE_EVENT0("blink_gc", "Heap::GCScope");
         const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
         if (m_state->isMainThread())
             TRACE_EVENT_SET_SAMPLING_STATE("blink_gc", "BlinkGCWaiting");
 
         m_state->checkThread();
 
         // FIXME: in an unlikely coincidence that two threads decide
         // to collect garbage at the same time, avoid doing two GCs in
         // a row.
-        RELEASE_ASSERT(!m_state->isInGC());
-        RELEASE_ASSERT(!m_state->isSweepInProgress());
         if (LIKELY(ThreadState::stopThreads())) {
             m_parkedAllThreads = true;
-            m_state->enterGC();
         }
         if (m_state->isMainThread())
             TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
     }
 
     bool allThreadsParked() { return m_parkedAllThreads; }
 
     ~GCScope()
     {
         // Only cleanup if we parked all threads in which case the GC happened
         // and we need to resume the other threads.
         if (LIKELY(m_parkedAllThreads)) {
-            m_state->leaveGC();
-            ASSERT(!m_state->isInGC());
             ThreadState::resumeThreads();
         }
     }
 
 private:
     ThreadState* m_state;
     ThreadState::SafePointScope m_safePointScope;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
@@ skipping 227 matching lines @@
 {
     ASSERT(allocationSize > remainingAllocationSize());
     if (allocationSize > blinkPageSize / 2)
         return allocateLargeObject(allocationSize, gcInfo);
 
     updateRemainingAllocationSize();
     if (threadState()->shouldGC()) {
         if (threadState()->shouldForceConservativeGC())
             Heap::collectGarbage(ThreadState::HeapPointersOnStack);
         else
-            threadState()->setGCRequested();
+            threadState()->setGCState(ThreadState::GCScheduled);
     }
     if (remainingAllocationSize() > 0) {
         m_freeList.addToFreeList(currentAllocationPoint(), remainingAllocationSize());
         setAllocationPoint(0, 0);
     }
     ensureCurrentAllocation(allocationSize, gcInfo);
     return allocate(payloadSize, gcInfo);
 }
 
 template<typename Header>
@@ skipping 314 matching lines @@
     allocationSize += headerPadding<Header>();
 
     // If ASan is supported we add allocationGranularity bytes to the allocated space and
     // poison that to detect overflows
 #if defined(ADDRESS_SANITIZER)
     allocationSize += allocationGranularity;
 #endif
 
     updateRemainingAllocationSize();
     if (m_threadState->shouldGC())
-        m_threadState->setGCRequested();
+        m_threadState->setGCState(ThreadState::GCScheduled);
     m_threadState->shouldFlushHeapDoesNotContainCache();
     PageMemory* pageMemory = PageMemory::allocate(allocationSize);
     m_threadState->allocatedRegionsSinceLastGC().append(pageMemory->region());
     Address largeObjectAddress = pageMemory->writableStart();
     Address headerAddress = largeObjectAddress + sizeof(LargeObject<Header>) + headerPadding<Header>();
     memset(headerAddress, 0, size);
     Header* header = new (NotNull, headerAddress) Header(size, gcInfo);
     Address result = headerAddress + sizeof(*header);
     ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
     LargeObject<Header>* largeObject = new (largeObjectAddress) LargeObject<Header>(pageMemory, gcInfo, threadState());
@@ skipping 843 matching lines @@
     if (json) {
         json->setInteger("class", tag);
         json->setInteger("size", header->size());
         json->setInteger("isMarked", isMarked());
     }
 }
 #endif
 
 void HeapDoesNotContainCache::flush()
 {
-    ASSERT(ThreadState::isAnyThreadInGC());
+    ASSERT(Heap::isInGC());
 
     if (m_hasEntries) {
         for (int i = 0; i < numberOfEntries; i++)
             m_entries[i] = 0;
         m_hasEntries = false;
     }
 }
 
 size_t HeapDoesNotContainCache::hash(Address address)
 {
     size_t value = (reinterpret_cast<size_t>(address) >> blinkPageSizeLog2);
     value ^= value >> numberOfEntriesLog2;
     value ^= value >> (numberOfEntriesLog2 * 2);
     value &= numberOfEntries - 1;
     return value & ~1; // Returns only even number.
 }
 
 bool HeapDoesNotContainCache::lookup(Address address)
 {
-    ASSERT(ThreadState::isAnyThreadInGC());
+    ASSERT(Heap::isInGC());
 
     size_t index = hash(address);
     ASSERT(!(index & 1));
     Address cachePage = roundToBlinkPageStart(address);
     if (m_entries[index] == cachePage)
         return m_entries[index];
     if (m_entries[index + 1] == cachePage)
         return m_entries[index + 1];
     return 0;
 }
 
 void HeapDoesNotContainCache::addEntry(Address address)
 {
-    ASSERT(ThreadState::isAnyThreadInGC());
+    ASSERT(Heap::isInGC());
 
     m_hasEntries = true;
     size_t index = hash(address);
     ASSERT(!(index & 1));
     Address cachePage = roundToBlinkPageStart(address);
     m_entries[index + 1] = m_entries[index];
     m_entries[index] = cachePage;
 }
 
 void Heap::flushHeapDoesNotContainCache()
@@ skipping 21 matching lines @@
     inline void visitHeader(HeapObjectHeader* header, const void* objectPointer, TraceCallback callback)
     {
         ASSERT(header);
 #if ENABLE(ASSERT)
         {
             // Check that we are not marking objects that are outside
             // the heap by calling Heap::contains. However we cannot
             // call Heap::contains when outside a GC and we call mark
             // when doing weakness for ephemerons. Hence we only check
             // when called within.
-            ASSERT(!ThreadState::isAnyThreadInGC() || Heap::containedInHeapOrOrphanedPage(header));
+            ASSERT(!Heap::isInGC() || Heap::containedInHeapOrOrphanedPage(header));
         }
 #endif
         ASSERT(objectPointer);
         if (header->isMarked())
             return;
         header->mark();
 #if ENABLE(GC_PROFILE_MARKING)
         MutexLocker locker(objectGraphMutex());
         String className(classOf(objectPointer));
         {
@@ skipping 202 matching lines @@
     s_shutdownCalled = true;
     ThreadState::shutdownHeapIfNecessary();
 }
 
 void Heap::doShutdown()
 {
     // We don't want to call doShutdown() twice.
     if (!s_markingVisitor)
         return;
 
-    ASSERT(!ThreadState::isAnyThreadInGC());
+    ASSERT(!Heap::isInGC());
     ASSERT(!ThreadState::attachedThreads().size());
     delete s_markingVisitor;
     s_markingVisitor = 0;
     delete s_heapDoesNotContainCache;
     s_heapDoesNotContainCache = 0;
     delete s_freePagePool;
     s_freePagePool = 0;
     delete s_orphanedPagePool;
     s_orphanedPagePool = 0;
     delete s_weakCallbackStack;
     s_weakCallbackStack = 0;
     delete s_postMarkingCallbackStack;
     s_postMarkingCallbackStack = 0;
     delete s_markingStack;
     s_markingStack = 0;
     delete s_ephemeronStack;
     s_ephemeronStack = 0;
     delete s_regionTree;
     s_regionTree = 0;
     ThreadState::shutdown();
     ASSERT(Heap::allocatedSpace() == 0);
 }
 
 BaseHeapPage* Heap::contains(Address address)
 {
-    ASSERT(ThreadState::isAnyThreadInGC());
+    ASSERT(Heap::isInGC());
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         BaseHeapPage* page = (*it)->contains(address);
         if (page)
             return page;
     }
     return 0;
 }
 
 #if ENABLE(ASSERT)
 bool Heap::containedInHeapOrOrphanedPage(void* object)
 {
     return contains(object) || orphanedPagePool()->contains(object);
 }
 #endif
 
 Address Heap::checkAndMarkPointer(Visitor* visitor, Address address)
 {
-    ASSERT(ThreadState::isAnyThreadInGC());
+    ASSERT(Heap::isInGC());
 
 #if !ENABLE(ASSERT)
     if (s_heapDoesNotContainCache->lookup(address))
         return 0;
 #endif
 
     if (BaseHeapPage* page = lookup(address)) {
         ASSERT(page->contains(address));
         ASSERT(!page->orphaned());
         ASSERT(!s_heapDoesNotContainCache->lookup(address));
@@ skipping 170 matching lines @@
 }
 
 #if ENABLE(ASSERT)
 bool Heap::weakTableRegistered(const void* table)
 {
     ASSERT(s_ephemeronStack);
     return s_ephemeronStack->hasCallbackForObject(table);
 }
 #endif
 
-void Heap::prepareForGC()
+void Heap::preGC()
 {
-    ASSERT(ThreadState::isAnyThreadInGC());
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
-        (*it)->prepareForGC();
+        (*it)->preGC();
+}
+
+void Heap::postGC()
+{
+    ASSERT(Heap::isInGC());
+    ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
+    for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
+        (*it)->postGC();
 }
 
 void Heap::collectGarbage(ThreadState::StackState stackState, ThreadState::CauseOfGC cause)
 {
     ThreadState* state = ThreadState::current();
-    state->clearGCRequested();
+    state->setGCState(ThreadState::StoppingOtherThreads);
 
     GCScope gcScope(stackState);
     // Check if we successfully parked the other threads. If not we bail out of the GC.
     if (!gcScope.allThreadsParked()) {
-        ThreadState::current()->setGCRequested();
+        state->setGCState(ThreadState::GCScheduled);
         return;
     }
 
     if (state->isMainThread())
         ScriptForbiddenScope::enter();
 
     s_lastGCWasConservative = false;
 
-    Heap::resetMarkedObjectSize();
-    Heap::resetAllocatedObjectSize();
-
     TRACE_EVENT2("blink_gc", "Heap::collectGarbage",
         "precise", stackState == ThreadState::NoHeapPointersOnStack,
         "forced", cause == ThreadState::ForcedGC);
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
     double timeStamp = WTF::currentTimeMS();
 #if ENABLE(GC_PROFILE_MARKING)
     static_cast<MarkingVisitor*>(s_markingVisitor)->objectGraph().clear();
 #endif
 
     // Disallow allocation during garbage collection (but not
     // during the finalization that happens when the gcScope is
     // torn down).
     NoAllocationScope<AnyThread> noAllocationScope;
 
-    prepareForGC();
+    enterGC();
+    preGC();
+
+    Heap::resetMarkedObjectSize();
+    Heap::resetAllocatedObjectSize();
 
     // 1. trace persistent roots.
     ThreadState::visitPersistentRoots(s_markingVisitor);
 
     // 2. trace objects reachable from the persistent roots including ephemerons.
     processMarkingStack<GlobalMarking>();
 
     // 3. trace objects reachable from the stack. We do this independent of the
     // given stackState since other threads might have a different stack state.
     ThreadState::visitStackRoots(s_markingVisitor);
 
     // 4. trace objects reachable from the stack "roots" including ephemerons.
     // Only do the processing if we found a pointer to an object on one of the
     // thread stacks.
     if (lastGCWasConservative()) {
         processMarkingStack<GlobalMarking>();
     }
 
     postMarkingProcessing();
     globalWeakProcessing();
 
     // Now we can delete all orphaned pages because there are no dangling
     // pointers to the orphaned pages. (If we have such dangling pointers,
     // we should have crashed during marking before getting here.)
     orphanedPagePool()->decommitOrphanedPages();
 
+    postGC();
+    leaveGC();
+
 #if ENABLE(GC_PROFILE_MARKING)
     static_cast<MarkingVisitor*>(s_markingVisitor)->reportStats();
 #endif
 
     if (Platform::current()) {
         Platform::current()->histogramCustomCounts("BlinkGC.CollectGarbage", WTF::currentTimeMS() - timeStamp, 0, 10 * 1000, 50);
         Platform::current()->histogramCustomCounts("BlinkGC.TotalObjectSpace", Heap::allocatedObjectSize() / 1024, 0, 4 * 1024 * 1024, 50);
         Platform::current()->histogramCustomCounts("BlinkGC.TotalAllocatedSpace", Heap::allocatedSpace() / 1024, 0, 4 * 1024 * 1024, 50);
     }
 
     if (state->isMainThread())
         ScriptForbiddenScope::exit();
 }
 
 void Heap::collectGarbageForTerminatingThread(ThreadState* state)
 {
     // We explicitly do not enter a safepoint while doing thread specific
     // garbage collection since we don't want to allow a global GC at the
     // same time as a thread local GC.
 
     {
         NoAllocationScope<AnyThread> noAllocationScope;
 
-        state->enterGC();
-        state->prepareForGC();
+        enterGC();
+        state->preGC();
 
         // 1. trace the thread local persistent roots. For thread local GCs we
         // don't trace the stack (ie. no conservative scanning) since this is
         // only called during thread shutdown where there should be no objects
         // on the stack.
         // We also assume that orphaned pages have no objects reachable from
         // persistent handles on other threads or CrossThreadPersistents. The
         // only cases where this could happen is if a subsequent conservative
         // global GC finds a "pointer" on the stack or due to a programming
         // error where an object has a dangling cross-thread pointer to an
         // object on this heap.
         state->visitPersistents(s_markingVisitor);
 
         // 2. trace objects reachable from the thread's persistent roots
         // including ephemerons.
         processMarkingStack<ThreadLocalMarking>();
 
         postMarkingProcessing();
         globalWeakProcessing();
 
-        state->leaveGC();
+        state->postGC();
+        leaveGC();
     }
     state->performPendingSweep();
 }
 
 template<CallbackInvocationMode Mode>
 void Heap::processMarkingStack()
 {
     // Ephemeron fixed point loop.
     do {
         {
@@ skipping 68 matching lines @@
     for (HeapPage<Header>* page = m_firstPage; page; page = page->next()) {
         page->setTerminating();
     }
     for (LargeObject<Header>* largeObject = m_firstLargeObject; largeObject; largeObject = largeObject->next()) {
         largeObject->setTerminating();
     }
 }
 size_t Heap::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
-    ASSERT(ThreadState::isAnyThreadInGC());
+    ASSERT(Heap::isInGC());
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     typedef ThreadState::AttachedThreadStateSet::iterator ThreadStateIterator;
     for (ThreadStateIterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         (*it)->makeConsistentForSweeping();
         objectPayloadSize += (*it)->objectPayloadSizeForTesting();
     }
     return objectPayloadSize;
 }
 
 template<typename HeapTraits, typename HeapType, typename HeaderType>
 void HeapAllocator::backingFree(void* address)
 {
-    if (!address || ThreadState::isAnyThreadInGC())
+    if (!address || Heap::isInGC())
         return;
 
     ThreadState* state = ThreadState::current();
     if (state->isSweepInProgress())
         return;
 
     // Don't promptly free large objects because their page is never reused
     // and don't free backings allocated on other threads.
     BaseHeapPage* page = pageFromObject(address);
     if (page->isLargeObject() || page->threadState() != state)
@@ skipping 20 matching lines @@
 {
     typedef HeapIndexTrait<HashTableBackingHeap> HeapTraits;
     typedef HeapTraits::HeapType HeapType;
     typedef HeapTraits::HeaderType HeaderType;
     backingFree<HeapTraits, HeapType, HeaderType>(address);
 }
 
 template<typename HeapTraits, typename HeapType, typename HeaderType>
 bool HeapAllocator::backingExpand(void* address, size_t newSize)
 {
-    if (!address || ThreadState::isAnyThreadInGC())
+    if (!address || Heap::isInGC())
         return false;
 
     ThreadState* state = ThreadState::current();
     if (state->isSweepInProgress())
         return false;
     ASSERT(state->isAllocationAllowed());
 
     BaseHeapPage* page = pageFromObject(address);
     if (page->isLargeObject() || page->threadState() != state)
         return false;
@@ skipping 10 matching lines @@
 bool HeapAllocator::vectorBackingExpand(void* address, size_t newSize)
 {
     typedef HeapIndexTrait<VectorBackingHeap> HeapTraits;
     typedef HeapTraits::HeapType HeapType;
     typedef HeapTraits::HeaderType HeaderType;
     return backingExpand<HeapTraits, HeapType, HeaderType>(address, newSize);
 }
 
 BaseHeapPage* Heap::lookup(Address address)
 {
-    ASSERT(ThreadState::isAnyThreadInGC());
+    ASSERT(Heap::isInGC());
     if (!s_regionTree)
         return 0;
     if (PageMemoryRegion* region = s_regionTree->lookup(address)) {
         BaseHeapPage* page = region->pageFromAddress(address);
         return page && !page->orphaned() ? page : 0;
     }
     return 0;
 }
 
 static Mutex& regionTreeMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
 }
 
 void Heap::removePageMemoryRegion(PageMemoryRegion* region)
 {
     // Deletion of large objects (and thus their regions) can happen concurrently
     // on sweeper threads. Removal can also happen during thread shutdown, but
     // that case is safe. Regardless, we make all removals mutually exclusive.
     MutexLocker locker(regionTreeMutex());
     RegionTree::remove(region, &s_regionTree);
 }
 
 void Heap::addPageMemoryRegion(PageMemoryRegion* region)
 {
-    ASSERT(ThreadState::isAnyThreadInGC());
+    ASSERT(Heap::isInGC());
     RegionTree::add(new RegionTree(region), &s_regionTree);
 }
 
 PageMemoryRegion* Heap::RegionTree::lookup(Address address)
 {
     RegionTree* current = s_regionTree;
     while (current) {
         Address base = current->m_region->base();
         if (address < base) {
             current = current->m_left;
@@ skipping 55 matching lines @@
 template class ThreadHeap<HeapObjectHeader>;
 
 Visitor* Heap::s_markingVisitor;
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_postMarkingCallbackStack;
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
+bool Heap::s_inGC = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = 0;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink