Remove ParkThreadsScope

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 81 matching lines @@
     case BlinkGC::MemoryPressureGC:
       return "MemoryPressureGC";
     case BlinkGC::PageNavigationGC:
       return "PageNavigationGC";
     default:
       NOTREACHED();
   }
   return "<Unknown>";
 }
 
-class ParkThreadsScope final {
-  STACK_ALLOCATED();
-
- public:
-  explicit ParkThreadsScope(ThreadState* state)
-      : m_state(state), m_shouldResumeThreads(false) {}
-
-  bool parkThreads() {
-    TRACE_EVENT0("blink_gc", "ThreadHeap::ParkThreadsScope");
-
-    // TODO(haraken): In an unlikely coincidence that two threads decide
-    // to collect garbage at the same time, avoid doing two GCs in
-    // a row and return false.
-    double startTime = WTF::currentTimeMS();
-
-    m_shouldResumeThreads = m_state->heap().park();
-
-    double timeForStoppingThreads = WTF::currentTimeMS() - startTime;
-    DEFINE_THREAD_SAFE_STATIC_LOCAL(
-        CustomCountHistogram, timeToStopThreadsHistogram,
-        new CustomCountHistogram("BlinkGC.TimeForStoppingThreads", 1, 1000,
-                                 50));
-    timeToStopThreadsHistogram.count(timeForStoppingThreads);
-
-    return m_shouldResumeThreads;
-  }
-
-  ~ParkThreadsScope() {
-    // Only cleanup if we parked all threads in which case the GC happened
-    // and we need to resume the other threads.
-    if (m_shouldResumeThreads)
-      m_state->heap().resume();
-  }
-
- private:
-  ThreadState* m_state;
-  bool m_shouldResumeThreads;
-};
-
 ThreadState::ThreadState()
     : m_thread(currentThread()),
       m_persistentRegion(WTF::makeUnique<PersistentRegion>()),
       m_startOfStack(reinterpret_cast<intptr_t*>(WTF::getStackStart())),
       m_endOfStack(reinterpret_cast<intptr_t*>(WTF::getStackStart())),
       m_safePointScopeMarker(nullptr),
       m_atSafePoint(false),
       m_interruptors(),
       m_sweepForbidden(false),
       m_noAllocationCount(0),
@@ skipping 1412 matching lines @@
   // 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);
 
   {
     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, Visitor::SnapshotMarking);
     } else {
       DCHECK(gcType == BlinkGC::GCWithSweep ||
              gcType == BlinkGC::GCWithoutSweep);
       if (heap().compaction()->shouldCompact(this, gcType, reason)) {
         heap().compaction()->initialize(this);
         visitor = Visitor::create(this, Visitor::GlobalMarkingWithCompaction);
       } else {
@@ skipping 94 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink