[oilpan]: optimize the way we allocate persistent handles in wrappers.

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 247 matching lines @@
         barrier->doEnterSafePoint(state, stackEnd);
     }
 
     volatile int m_canResume;
     volatile int m_unparkedThreadCount;
     Mutex m_mutex;
     ThreadCondition m_parked;
     ThreadCondition m_resume;
 };
 
-
 BaseHeapPage::BaseHeapPage(PageMemory* storage, const GCInfo* gcInfo, ThreadState* state)
     : m_storage(storage)
     , m_gcInfo(gcInfo)
     , m_threadState(state)
     , m_terminating(false)
     , m_tracedAfterOrphaned(false)
 {
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
 // Statically unfold the heap initialization loop so the compiler statically
 // knows the heap index when using HeapIndexTrait.
 template<int num> struct InitializeHeaps {
     static const int index = num - 1;
     static void init(BaseHeap** heaps, ThreadState* state)
     {
         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_wrapperPersistents(new WrapperPersistentRegion())
+    , m_wrapperPersistentRegionPool(0)
+    , m_wrapperPersistentRegionPoolSize(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)
@@ skipping 18 matching lines @@
         m_sweeperThread = adoptPtr(blink::Platform::current()->createThread("Blink GC Sweeper"));
 }
 
 ThreadState::~ThreadState()
 {
     checkThread();
     CallbackStack::shutdown(&m_weakCallbackStack);
     for (int i = 0; i < NumberOfHeaps; i++)
         delete m_heaps[i];
     deleteAllValues(m_interruptors);
+    while (m_wrapperPersistents) {

[Mads Ager (chromium), 2014/09/01 13:52:46]

How about regions that are in the pool? Should we delete those here as well?

[wibling-chromium, 2014/09/02 11:19:38]

That seems like a good idea:) Fixed.

+        WrapperPersistentRegion* region = WrapperPersistentRegion::removeHead(&m_wrapperPersistents);
+        delete region;
+    }
     **s_threadSpecific = 0;
 }
 
 void ThreadState::init()
 {
     s_threadSpecific = new WTF::ThreadSpecific<ThreadState*>();
     s_safePointBarrier = new SafePointBarrier;
 }
 
 void ThreadState::shutdown()
@@ skipping 211 matching lines @@
         __msan_unpoison(&ptr, sizeof(ptr));
 #endif
         Heap::checkAndMarkPointer(visitor, ptr);
         visitAsanFakeStackForPointer(visitor, ptr);
     }
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)
 {
     m_persistents->trace(visitor);
+    m_wrapperPersistents->trace(visitor);
 }
 
 bool ThreadState::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     // If thread is terminating ignore conservative pointers.
     if (m_isTerminating)
         return false;
 
     // This checks for normal pages and for large objects which span the extent
     // of several normal pages.
@@ skipping 99 matching lines @@
 {
     CallbackStack::Item* slot = m_weakCallbackStack->allocateEntry(&m_weakCallbackStack);
     *slot = CallbackStack::Item(object, callback);
 }
 
 bool ThreadState::popAndInvokeWeakPointerCallback(Visitor* visitor)
 {
     return m_weakCallbackStack->popAndInvokeCallback<WeaknessProcessing>(&m_weakCallbackStack, visitor);
 }
 
+WrapperPersistentRegion* ThreadState::addWrapperPersistentRegion()
+{
+    WrapperPersistentRegion* region;
+    if (m_wrapperPersistentRegionPoolSize) {
+        region = WrapperPersistentRegion::removeHead(&m_wrapperPersistentRegionPool);
+        m_wrapperPersistentRegionPoolSize--;
+    } else {
+        region = new WrapperPersistentRegion();
+    }
+    ASSERT(region);
+    WrapperPersistentRegion::insertHead(&m_wrapperPersistents, region);
+    return region;
+}
+
+void ThreadState::removeWrapperPersistentRegion(WrapperPersistentRegion* region)
+{
+    ASSERT(!region->count());
+    if (!region->removeIfNotLast(&m_wrapperPersistents))
+        return;
+
+    // Region was removed, ie. it is was not the last region in the list.

[haraken, 2014/09/02 05:22:06]

it is was => it was

[wibling-chromium, 2014/09/02 11:19:38]

Done.

+    if (m_wrapperPersistentRegionPoolSize < 2) {

[haraken, 2014/09/02 05:22:06]

What does the '< 2' check mean?

[wibling-chromium, 2014/09/02 11:19:38]

It means we will only keep at most two regions in the pool. This is to avoid
having too large a memory overhead.

+        WrapperPersistentRegion::insertHead(&m_wrapperPersistentRegionPool, region);
+        m_wrapperPersistentRegionPoolSize++;
+    } else {
+        delete region;
+    }
+}
+
 PersistentNode* ThreadState::globalRoots()
 {
     AtomicallyInitializedStatic(PersistentNode*, anchor = new PersistentAnchor);
     return anchor;
 }
 
 Mutex& ThreadState::globalRootsMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
@@ skipping 501 matching lines @@
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 
 }