Remove thread-local weak processing

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 99 matching lines @@
       m_sweepForbidden(false),
       m_noAllocationCount(0),
       m_gcForbiddenCount(0),
       m_mixinsBeingConstructedCount(0),
       m_accumulatedSweepingTime(0),
       m_vectorBackingArenaIndex(BlinkGC::Vector1ArenaIndex),
       m_currentArenaAges(0),
       m_gcMixinMarker(nullptr),
       m_shouldFlushHeapDoesNotContainCache(false),
       m_gcState(NoGCScheduled),
-      m_threadLocalWeakCallbackStack(CallbackStack::create()),
       m_isolate(nullptr),
       m_traceDOMWrappers(nullptr),
       m_invalidateDeadObjectsInWrappersMarkingDeque(nullptr),
 #if defined(ADDRESS_SANITIZER)
       m_asanFakeStack(__asan_get_current_fake_stack()),
 #endif
 #if defined(LEAK_SANITIZER)
       m_disabledStaticPersistentsRegistration(0),
 #endif
       m_allocatedObjectSize(0),
@@ skipping 167 matching lines @@
     m_traceDOMWrappers(m_isolate, visitor);
   }
 }
 
 ThreadState::GCSnapshotInfo::GCSnapshotInfo(size_t numObjectTypes)
     : liveCount(Vector<int>(numObjectTypes)),
       deadCount(Vector<int>(numObjectTypes)),
       liveSize(Vector<size_t>(numObjectTypes)),
       deadSize(Vector<size_t>(numObjectTypes)) {}
 
-void ThreadState::pushThreadLocalWeakCallback(void* object,
-                                              WeakCallback callback) {
-  CallbackStack::Item* slot = m_threadLocalWeakCallbackStack->allocateEntry();
-  *slot = CallbackStack::Item(object, callback);
-}
-
-bool ThreadState::popAndInvokeThreadLocalWeakCallback(Visitor* visitor) {
-  ASSERT(checkThread());
-  if (CallbackStack::Item* item = m_threadLocalWeakCallbackStack->pop()) {
-    item->call(visitor);
-    return true;
-  }
-  return false;
-}
-
-void ThreadState::threadLocalWeakProcessing() {
-  ASSERT(checkThread());
-  ASSERT(!sweepForbidden());
-  TRACE_EVENT0("blink_gc", "ThreadState::threadLocalWeakProcessing");
-  double startTime = WTF::currentTimeMS();
-
-  SweepForbiddenScope sweepForbiddenScope(this);
-  ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
-
-  // Disallow allocation during weak processing.
-  // It would be technically safe to allow allocations, but it is unsafe
-  // to mutate an object graph in a way in which a dead object gets
-  // resurrected or mutate a HashTable (because HashTable's weak processing
-  // assumes that the HashTable hasn't been mutated since the latest marking).
-  // Due to the complexity, we just forbid allocations.
-  NoAllocationScope noAllocationScope(this);
-
-  GCForbiddenScope gcForbiddenScope(this);
-  std::unique_ptr<Visitor> visitor =
-      Visitor::create(this, Visitor::WeakProcessing);
-
-  // Perform thread-specific weak processing.
-  while (popAndInvokeThreadLocalWeakCallback(visitor.get())) {
-  }
-
-  m_threadLocalWeakCallbackStack->decommit();
-
-  if (isMainThread()) {
-    double timeForThreadLocalWeakProcessing = WTF::currentTimeMS() - startTime;
-    DEFINE_STATIC_LOCAL(
-        CustomCountHistogram, timeForWeakHistogram,
-        ("BlinkGC.TimeForThreadLocalWeakProcessing", 1, 10 * 1000, 50));
-    timeForWeakHistogram.count(timeForThreadLocalWeakProcessing);
-  }
-}
-
 size_t ThreadState::totalMemorySize() {
   return m_heap->heapStats().allocatedObjectSize() +
          m_heap->heapStats().markedObjectSize() +
          WTF::Partitions::totalSizeOfCommittedPages();
 }
 
 size_t ThreadState::estimatedLiveSize(size_t estimationBaseSize,
                                       size_t sizeAtLastGC) {
   if (m_heap->heapStats().wrapperCountAtLastGC() == 0) {
     // We'll reach here only before hitting the first GC.
@@ skipping 534 matching lines @@
 
 void ThreadState::preGC() {
   if (m_isolate && m_performCleanup)
     m_performCleanup(m_isolate);
 
   ASSERT(!isInGC());
   setGCState(GCRunning);
   makeConsistentForGC();
   flushHeapDoesNotContainCacheIfNeeded();
   clearArenaAges();
-
-  // It is possible, albeit rare, for a thread to be kept
-  // at a safepoint across multiple GCs, as resuming all attached
-  // threads after the "global" GC phases will contend for the shared
-  // safepoint barrier mutexes etc, which can additionally delay
-  // a thread. Enough so that another thread may initiate
-  // a new GC before this has happened.
-  //
-  // In which case the parked thread's ThreadState will have unprocessed
-  // entries on its local weak callback stack when that later GC goes
-  // ahead. Clear out and invalidate the stack now, as the thread
-  // should only process callbacks that's found to be reachable by
-  // the latest GC, when it eventually gets to next perform
-  // thread-local weak processing.
-  m_threadLocalWeakCallbackStack->decommit();
-  m_threadLocalWeakCallbackStack->commit();
 }
 
 void ThreadState::postGC(BlinkGC::GCType gcType) {
   if (m_invalidateDeadObjectsInWrappersMarkingDeque)
     m_invalidateDeadObjectsInWrappersMarkingDeque(m_isolate);
 
-  ASSERT(isInGC());
+  DCHECK(isInGC());
+  DCHECK(checkThread());
   for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
     m_arenas[i]->prepareForSweep();
 
   if (gcType == BlinkGC::TakeSnapshot) {
     takeSnapshot(SnapshotType::HeapSnapshot);
 
     // This unmarks all marked objects and marks all unmarked objects dead.
     makeConsistentForMutator();
 
     takeSnapshot(SnapshotType::FreelistSnapshot);
 
     // 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.
@@ skipping 673 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink