Oilpan: Introduce memory pool for CallbackStacks

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 118 matching lines @@
     ASSERT(m_heap);
     m_heap->attach(this);
 
     for (int arenaIndex = 0; arenaIndex < BlinkGC::LargeObjectArenaIndex; arenaIndex++)
         m_arenas[arenaIndex] = new NormalPageArena(this, arenaIndex);
     m_arenas[BlinkGC::LargeObjectArenaIndex] = new LargeObjectArena(this, BlinkGC::LargeObjectArenaIndex);
 
     m_likelyToBePromptlyFreed = wrapArrayUnique(new int[likelyToBePromptlyFreedArraySize]);
     clearArenaAges();
 
-    // There is little use of weak references and collections off the main thread;
-    // use a much lower initial block reservation.
-    size_t initialBlockSize = isMainThread() ? CallbackStack::kDefaultBlockSize : CallbackStack::kMinimalBlockSize;
-    m_threadLocalWeakCallbackStack = new CallbackStack(initialBlockSize);
+    m_threadLocalWeakCallbackStack = new CallbackStack();
 }
 
 ThreadState::~ThreadState()
 {
     ASSERT(checkThread());
     delete m_threadLocalWeakCallbackStack;
     m_threadLocalWeakCallbackStack = nullptr;
     for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
         delete m_arenas[i];
 
@@ skipping 803 matching lines @@
     // 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->clear();
+    m_threadLocalWeakCallbackStack->decommit();

[sof, 2016/07/05 14:19:02]

Naming this clear() or reset() would be clearer, perhaps.

But, wouldn't it make sense to decommit the thread-local stack after having
completed the thread-local weak processing? If not, don't you risk having N
threads holding on to a pooled stack, but the GCing thread having to commit &
allocate its stacks from somewhere else.

[haraken, 2016/07/06 01:58:11]

We're already calling decommit() at the end of
ThreadState::threadLocalWeakProcessing().

I'd prefer "commit"/"decommit" to make the function names balanced (V8 is using
the names).

[sof, 2016/07/06 13:22:17]

Ah, of course we already are; good.
ok.

+    m_threadLocalWeakCallbackStack->commit();
 }
 
 void ThreadState::postGC(BlinkGC::GCType gcType)
 {
     if (RuntimeEnabledFeatures::traceWrappablesEnabled()
         && m_invalidateDeadObjectsInWrappersMarkingDeque) {
         m_invalidateDeadObjectsInWrappersMarkingDeque(m_isolate);
     }
 
     ASSERT(isInGC());
@@ skipping 556 matching lines @@
     threadDump->AddScalar("dead_count", "objects", totalDeadCount);
     threadDump->AddScalar("live_size", "bytes", totalLiveSize);
     threadDump->AddScalar("dead_size", "bytes", totalDeadSize);
 
     base::trace_event::MemoryAllocatorDump* heapsDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(heapsDumpName);
     base::trace_event::MemoryAllocatorDump* classesDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForCurrentGC(classesDumpName);
     BlinkGCMemoryDumpProvider::instance()->currentProcessMemoryDump()->AddOwnershipEdge(classesDump->guid(), heapsDump->guid());
 }
 
 } // namespace blink