Oilpan: DOM wrappers don't need to keep persistent handles

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 92 matching lines @@
 #ifdef _WIN64
     return reinterpret_cast<void*>(__readgsqword(offsetof(NT_TIB64, StackBase)));
 #else
     return reinterpret_cast<void*>(__readfsdword(offsetof(NT_TIB, StackBase)));
 #endif
 #else
 #error Unsupported getStackStart on this platform.
 #endif
 }
 
-// The maximum number of WrapperPersistentRegions to keep around in the
-// m_pooledWrapperPersistentRegions pool.
-static const size_t MaxPooledWrapperPersistentRegionCount = 2;
-
 WTF::ThreadSpecific<ThreadState*>* ThreadState::s_threadSpecific = 0;
 uint8_t ThreadState::s_mainThreadStateStorage[sizeof(ThreadState)];
 SafePointBarrier* ThreadState::s_safePointBarrier = 0;
 bool ThreadState::s_inGC = false;
 
 static Mutex& threadAttachMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
 }
@@ skipping 165 matching lines @@
         InitializeHeaps<index>::init(heaps, state);
         heaps[index] = new typename HeapIndexTrait<index>::HeapType(state, index);
     }
 };
 template<> struct InitializeHeaps<0> {
     static void init(BaseHeap** heaps, ThreadState* state) { }
 };
 
 ThreadState::ThreadState()
     : m_thread(currentThread())
-    , m_liveWrapperPersistents(new WrapperPersistentRegion())
-    , m_pooledWrapperPersistents(0)
-    , m_pooledWrapperPersistentRegionCount(0)
     , m_persistents(adoptPtr(new PersistentAnchor()))
     , m_startOfStack(reinterpret_cast<intptr_t*>(getStackStart()))
     , m_endOfStack(reinterpret_cast<intptr_t*>(getStackStart()))
     , m_safePointScopeMarker(0)
     , m_atSafePoint(false)
     , m_interruptors()
     , m_gcRequested(false)
     , m_forcePreciseGCForTesting(false)
     , m_sweepRequested(0)
     , m_sweepInProgress(false)
     , m_noAllocationCount(0)
     , m_inGC(false)
     , m_isTerminating(false)
     , m_shouldFlushHeapDoesNotContainCache(false)
     , m_lowCollectionRate(false)
     , m_numberOfSweeperTasks(0)
+    , m_traceDOMWrappers(0)

[tkent, 2014/10/15 03:48:35]

nit: We can use |nullptr|.

 #if defined(ADDRESS_SANITIZER)
     , m_asanFakeStack(__asan_get_current_fake_stack())
 #endif
 {
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
     InitializeHeaps<NumberOfHeaps>::init(m_heaps, this);
 
     m_weakCallbackStack = new CallbackStack();
 
     if (blink::Platform::current())
         m_sweeperThread = adoptPtr(blink::Platform::current()->createThread("Blink GC Sweeper"));
 }
 
 ThreadState::~ThreadState()
 {
     checkThread();
     delete m_weakCallbackStack;
     m_weakCallbackStack = 0;
     for (int i = 0; i < NumberOfHeaps; i++)
         delete m_heaps[i];
     deleteAllValues(m_interruptors);
-    while (m_liveWrapperPersistents) {
-        WrapperPersistentRegion* region = WrapperPersistentRegion::removeHead(&m_liveWrapperPersistents);
-        delete region;
-    }
-    while (m_pooledWrapperPersistents) {
-        WrapperPersistentRegion* region = WrapperPersistentRegion::removeHead(&m_pooledWrapperPersistents);
-        delete region;
-    }
     **s_threadSpecific = 0;
 }
 
 void ThreadState::init()
 {
     s_threadSpecific = new WTF::ThreadSpecific<ThreadState*>();
     s_safePointBarrier = new SafePointBarrier;
 }
 
 void ThreadState::shutdown()
@@ skipping 215 matching lines @@
         __msan_unpoison(&ptr, sizeof(ptr));
 #endif
         Heap::checkAndMarkPointer(visitor, ptr);
         visitAsanFakeStackForPointer(visitor, ptr);
     }
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)
 {
     m_persistents->trace(visitor);
-    {
-        TRACE_EVENT0("blink_gc", "WrapperPersistentRegion::trace");
-        WrapperPersistentRegion::trace(m_liveWrapperPersistents, visitor);
+    if (m_traceDOMWrappers) {
+        TRACE_EVENT0("blink_gc", "V8GCController::traceDOMWrappers");

[sof, 2014/10/12 20:40:43]

Push this down into V8GCController::traceDOMrappers() ?

+        m_traceDOMWrappers(visitor);
     }
 }
 
 #if ENABLE(GC_PROFILE_MARKING)
 const GCInfo* ThreadState::findGCInfo(Address address)
 {
     BaseHeapPage* page = heapPageFromAddress(address);
     if (page) {
         return page->findGCInfo(address);
     }
@@ skipping 88 matching lines @@
     // registered as objects on orphaned pages. We cannot assert this here since
     // we might have an off-heap collection. We assert it in
     // Heap::pushWeakObjectPointerCallback.
     if (CallbackStack::Item* item = m_weakCallbackStack->pop()) {
         item->call(visitor);
         return true;
     }
     return false;
 }
 
-WrapperPersistentRegion* ThreadState::takeWrapperPersistentRegion()
-{
-    WrapperPersistentRegion* region;
-    if (m_pooledWrapperPersistentRegionCount) {
-        region = WrapperPersistentRegion::removeHead(&m_pooledWrapperPersistents);
-        m_pooledWrapperPersistentRegionCount--;
-    } else {
-        region = new WrapperPersistentRegion();
-    }
-    ASSERT(region);
-    WrapperPersistentRegion::insertHead(&m_liveWrapperPersistents, region);
-    return region;
-}
-
-void ThreadState::freeWrapperPersistentRegion(WrapperPersistentRegion* region)
-{
-    if (!region->removeIfNotLast(&m_liveWrapperPersistents))
-        return;
-
-    // Region was removed, ie. it was not the last region in the list.
-    if (m_pooledWrapperPersistentRegionCount < MaxPooledWrapperPersistentRegionCount) {
-        WrapperPersistentRegion::insertHead(&m_pooledWrapperPersistents, region);
-        m_pooledWrapperPersistentRegionCount++;
-    } else {
-        delete region;
-    }
-}
-
 PersistentNode* ThreadState::globalRoots()
 {
     AtomicallyInitializedStatic(PersistentNode*, anchor = new PersistentAnchor);
     return anchor;
 }
 
 Mutex& ThreadState::globalRootsMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
@@ skipping 546 matching lines @@
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 
 }