Revert of Move postGC out of CrossThreadPersistentRegion::LockScope

third_party/WebKit/Source/platform/heap/ThreadState.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 1022 matching lines @@
 
     // Force setting NoGCScheduled to circumvent checkThread()
     // in setGCState().
     m_gcState = NoGCScheduled;
     return;
   }
 
   ASSERT(checkThread());
 
   threadLocalWeakProcessing();
-}
 
-void ThreadState::preSweep(BlinkGC::GCType gcType) {
-  if (gcState() == NoGCScheduled)
-    return;
   // We have to set the GCState to Sweeping before calling pre-finalizers
   // to disallow a GC during the pre-finalizers.
   setGCState(Sweeping);
 
   // Allocation is allowed during the pre-finalizers and destructors.
   // However, they must not mutate an object graph in a way in which
   // a dead object gets resurrected.
   invokePreFinalizers();
 
   m_accumulatedSweepingTime = 0;
@@ skipping 551 matching lines @@
       ->AddOwnershipEdge(classesDump->guid(), heapsDump->guid());
 }
 
 void ThreadState::collectGarbage(BlinkGC::StackState stackState,
                                  BlinkGC::GCType gcType,
                                  BlinkGC::GCReason reason) {
   // Nested collectGarbage() invocations aren't supported.
   RELEASE_ASSERT(!isGCForbidden());
   completeSweep();
 
+  // Access to the CrossThreadPersistentRegion has to be prevented while
+  // in the stop-the-world phase. If not, threads not attached to Oilpan
+  // and participating in this GC are able to allocate & free PersistentNodes,
+  // something the marking phase isn't capable of handling.
+  CrossThreadPersistentRegion::LockScope persistentLock(
+      ProcessHeap::crossThreadPersistentRegion());
+
   GCForbiddenScope gcForbiddenScope(this);
 
   {
-    // Access to the CrossThreadPersistentRegion has to be prevented while in
-    // the marking phase because otherwise other threads may allocate or free
-    // PersistentNodes and we can't handle that.
-    CrossThreadPersistentRegion::LockScope persistentLock(
-        ProcessHeap::crossThreadPersistentRegion());
+    SafePointScope safePointScope(stackState, this);
+
+    // Resume all parked threads upon leaving this scope.
+    ParkThreadsScope parkThreadsScope(this);
+
+    // Try to park the other threads. If we're unable to, bail out of the GC.
+    if (!parkThreadsScope.parkThreads())
+      return;
+
+    std::unique_ptr<Visitor> visitor;
+    if (gcType == BlinkGC::TakeSnapshot) {
+      visitor = Visitor::create(this, VisitorMarkingMode::SnapshotMarking);
+    } else {
+      DCHECK(gcType == BlinkGC::GCWithSweep ||
+             gcType == BlinkGC::GCWithoutSweep);
+      if (heap().compaction()->shouldCompact(this, gcType, reason)) {
+        heap().compaction()->initialize(this);
+        visitor = Visitor::create(
+            this, VisitorMarkingMode::GlobalMarkingWithCompaction);
+      } else {
+        visitor = Visitor::create(this, VisitorMarkingMode::GlobalMarking);
+      }
+    }
+
+    ScriptForbiddenIfMainThreadScope scriptForbidden;
+
+    TRACE_EVENT2("blink_gc,devtools.timeline", "BlinkGCMarking", "lazySweeping",
+                 gcType == BlinkGC::GCWithoutSweep, "gcReason",
+                 gcReasonString(reason));
+    double startTime = WTF::currentTimeMS();
+
+    if (gcType == BlinkGC::TakeSnapshot)
+      BlinkGCMemoryDumpProvider::instance()->clearProcessDumpForCurrentGC();
+
+    // Disallow allocation during garbage collection (but not during the
+    // finalization that happens when the visitorScope is torn down).
+    NoAllocationScope noAllocationScope(this);
+
+    heap().commitCallbackStacks();
+    heap().preGC();
+
+    StackFrameDepthScope stackDepthScope(&heap().stackFrameDepth());
+
+    size_t totalObjectSize = heap().heapStats().allocatedObjectSize() +
+                             heap().heapStats().markedObjectSize();
+    if (gcType != BlinkGC::TakeSnapshot)
+      heap().resetHeapCounters();
+
     {
-      SafePointScope safePointScope(stackState, this);
+      // 1. Trace persistent roots.
+      heap().visitPersistentRoots(visitor.get());
 
-      // Resume all parked threads upon leaving this scope.
-      ParkThreadsScope parkThreadsScope(this);
+      // 2. Trace objects reachable from the stack.  We do this independent of
+      // the
+      // given stackState since other threads might have a different stack
+      // state.
+      heap().visitStackRoots(visitor.get());
 
-      // Try to park the other threads. If we're unable to, bail out of the GC.
-      if (!parkThreadsScope.parkThreads())
-        return;
+      // 3. Transitive closure to trace objects including ephemerons.
+      heap().processMarkingStack(visitor.get());
 
-      std::unique_ptr<Visitor> visitor;
-      if (gcType == BlinkGC::TakeSnapshot) {
-        visitor = Visitor::create(this, VisitorMarkingMode::SnapshotMarking);
-      } else {
-        DCHECK(gcType == BlinkGC::GCWithSweep ||
-               gcType == BlinkGC::GCWithoutSweep);
-        if (heap().compaction()->shouldCompact(this, gcType, reason)) {
-          heap().compaction()->initialize(this);
-          visitor = Visitor::create(
-              this, VisitorMarkingMode::GlobalMarkingWithCompaction);
-        } else {
-          visitor = Visitor::create(this, VisitorMarkingMode::GlobalMarking);
-      }
+      heap().postMarkingProcessing(visitor.get());
+      heap().globalWeakProcessing(visitor.get());
+    }
 
-      ScriptForbiddenIfMainThreadScope scriptForbidden;
+    // 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.)
+    heap().getOrphanedPagePool()->decommitOrphanedPages();
 
-      TRACE_EVENT2("blink_gc,devtools.timeline", "BlinkGCMarking",
-                   "lazySweeping", gcType == BlinkGC::GCWithoutSweep,
-                   "gcReason", gcReasonString(reason));
-      double startTime = WTF::currentTimeMS();
-
-      if (gcType == BlinkGC::TakeSnapshot)
-        BlinkGCMemoryDumpProvider::instance()->clearProcessDumpForCurrentGC();
-
-      // Disallow allocation during garbage collection (but not during the
-      // finalization that happens when the visitorScope is torn down).
-      NoAllocationScope noAllocationScope(this);
-
-      heap().commitCallbackStacks();
-      heap().preGC();
-
-      StackFrameDepthScope stackDepthScope(&heap().stackFrameDepth());
-
-      size_t totalObjectSize = heap().heapStats().allocatedObjectSize() +
-                               heap().heapStats().markedObjectSize();
-      if (gcType != BlinkGC::TakeSnapshot)
-        heap().resetHeapCounters();
-
-      {
-        // 1. Trace persistent roots.
-        heap().visitPersistentRoots(visitor.get());
-
-        // 2. Trace objects reachable from the stack.  We do this independent of
-        // the
-        // given stackState since other threads might have a different stack
-        // state.
-        heap().visitStackRoots(visitor.get());
-
-        // 3. Transitive closure to trace objects including ephemerons.
-        heap().processMarkingStack(visitor.get());
-
-        heap().postMarkingProcessing(visitor.get());
-        heap().globalWeakProcessing(visitor.get());
-      }
-
-      // 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.)
-      heap().getOrphanedPagePool()->decommitOrphanedPages();
-
-      double markingTimeInMilliseconds = WTF::currentTimeMS() - startTime;
-      heap().heapStats().setEstimatedMarkingTimePerByte(
-          totalObjectSize ? (markingTimeInMilliseconds / 1000 / totalObjectSize)
-                          : 0);
+    double markingTimeInMilliseconds = WTF::currentTimeMS() - startTime;
+    heap().heapStats().setEstimatedMarkingTimePerByte(
+        totalObjectSize ? (markingTimeInMilliseconds / 1000 / totalObjectSize)
+                        : 0);
 
 #if PRINT_HEAP_STATS
-      dataLogF(
-          "ThreadHeap::collectGarbage (gcReason=%s, lazySweeping=%d, "
-          "time=%.1lfms)\n",
-          gcReasonString(reason), gcType == BlinkGC::GCWithoutSweep,
-          markingTimeInMilliseconds);
+    dataLogF(
+        "ThreadHeap::collectGarbage (gcReason=%s, lazySweeping=%d, "
+        "time=%.1lfms)\n",
+        gcReasonString(reason), gcType == BlinkGC::GCWithoutSweep,
+        markingTimeInMilliseconds);
 #endif
 
-      DEFINE_THREAD_SAFE_STATIC_LOCAL(
-          CustomCountHistogram, markingTimeHistogram,
-          new CustomCountHistogram("BlinkGC.CollectGarbage", 0, 10 * 1000, 50));
-      markingTimeHistogram.count(markingTimeInMilliseconds);
-      DEFINE_THREAD_SAFE_STATIC_LOCAL(
-          CustomCountHistogram, totalObjectSpaceHistogram,
-          new CustomCountHistogram("BlinkGC.TotalObjectSpace", 0, 4 * 1024 * 1024,
-                                   50));
-      totalObjectSpaceHistogram.count(ProcessHeap::totalAllocatedObjectSize() /
-                                      1024);
-      DEFINE_THREAD_SAFE_STATIC_LOCAL(
-          CustomCountHistogram, totalAllocatedSpaceHistogram,
-          new CustomCountHistogram("BlinkGC.TotalAllocatedSpace", 0,
-                                   4 * 1024 * 1024, 50));
-      totalAllocatedSpaceHistogram.count(ProcessHeap::totalAllocatedSpace() /
-                                         1024);
-      DEFINE_THREAD_SAFE_STATIC_LOCAL(
-          EnumerationHistogram, gcReasonHistogram,
-          new EnumerationHistogram("BlinkGC.GCReason",
-                                   BlinkGC::NumberOfGCReason));
-      gcReasonHistogram.count(reason);
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(
+        CustomCountHistogram, markingTimeHistogram,
+        new CustomCountHistogram("BlinkGC.CollectGarbage", 0, 10 * 1000, 50));
+    markingTimeHistogram.count(markingTimeInMilliseconds);
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(
+        CustomCountHistogram, totalObjectSpaceHistogram,
+        new CustomCountHistogram("BlinkGC.TotalObjectSpace", 0, 4 * 1024 * 1024,
+                                 50));
+    totalObjectSpaceHistogram.count(ProcessHeap::totalAllocatedObjectSize() /
+                                    1024);
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(
+        CustomCountHistogram, totalAllocatedSpaceHistogram,
+        new CustomCountHistogram("BlinkGC.TotalAllocatedSpace", 0,
+                                 4 * 1024 * 1024, 50));
+    totalAllocatedSpaceHistogram.count(ProcessHeap::totalAllocatedSpace() /
+                                       1024);
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(
+        EnumerationHistogram, gcReasonHistogram,
+        new EnumerationHistogram("BlinkGC.GCReason",
+                                 BlinkGC::NumberOfGCReason));
+    gcReasonHistogram.count(reason);
 
-      heap().m_lastGCReason = reason;
+    heap().m_lastGCReason = reason;
 
-      ThreadHeap::reportMemoryUsageHistogram();
-      WTF::Partitions::reportMemoryUsageHistogram();
-    }
-    heap().postGC(gcType);
+    ThreadHeap::reportMemoryUsageHistogram();
+    WTF::Partitions::reportMemoryUsageHistogram();
   }
 
-  heap().preSweep(gcType);
+  heap().postGC(gcType);
   heap().decommitCallbackStacks();
 }
 
 void ThreadState::collectGarbageForTerminatingThread() {
   // A thread-specific termination GC must not allow other global GCs to go
   // ahead while it is running, hence the termination GC does not enter a
   // safepoint. VisitorScope will not enter also a safepoint scope for
   // ThreadTerminationGC.
   GCForbiddenScope gcForbiddenScope(this);
 
@@ skipping 20 matching lines @@
 
     // 2. Trace objects reachable from the thread's persistent roots
     // including ephemerons.
     heap().processMarkingStack(visitor.get());
 
     heap().postMarkingProcessing(visitor.get());
     heap().globalWeakProcessing(visitor.get());
   }
 
   postGC(BlinkGC::GCWithSweep);
-  preSweep(BlinkGC::GCWithSweep);
   heap().decommitCallbackStacks();
 }
 
 void ThreadState::collectAllGarbage() {
   // We need to run multiple GCs to collect a chain of persistent handles.
   size_t previousLiveObjects = 0;
   for (int i = 0; i < 5; ++i) {
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink