Oilpan: Introduce memory pool for CallbackStacks

third_party/WebKit/Source/platform/heap/Heap.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 @@
 
 void ProcessHeap::init()
 {
     s_shutdownComplete = false;
     s_totalAllocatedSpace = 0;
     s_totalAllocatedObjectSize = 0;
     s_totalMarkedObjectSize = 0;
     s_isLowEndDevice = base::SysInfo::IsLowEndDevice();
 
     GCInfoTable::init();
+    CallbackStackMemoryPool::instance().initialize();
 }
 
 void ProcessHeap::resetHeapCounters()
 {
     s_totalAllocatedObjectSize = 0;
     s_totalMarkedObjectSize = 0;
 }
 
 void ProcessHeap::shutdown()
 {
     ASSERT(!s_shutdownComplete);
 
     {
         // The main thread must be the last thread that gets detached.
         MutexLocker locker(ThreadHeap::allHeapsMutex());
         RELEASE_ASSERT(ThreadHeap::allHeaps().isEmpty());
     }
 
+    CallbackStackMemoryPool::instance().shutdown();
     GCInfoTable::shutdown();
     ASSERT(ProcessHeap::totalAllocatedSpace() == 0);
     s_shutdownComplete = true;
 }
 
 CrossThreadPersistentRegion& ProcessHeap::crossThreadPersistentRegion()
 {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(CrossThreadPersistentRegion, persistentRegion, new CrossThreadPersistentRegion());
     return persistentRegion;
 }
@@ skipping 70 matching lines @@
     atomicSubtract(&m_allocatedSpace, static_cast<long>(delta));
     ProcessHeap::decreaseTotalAllocatedSpace(delta);
 }
 
 ThreadHeap::ThreadHeap()
     : m_regionTree(wrapUnique(new RegionTree()))
     , m_heapDoesNotContainCache(wrapUnique(new HeapDoesNotContainCache))
     , m_safePointBarrier(wrapUnique(new SafePointBarrier()))
     , m_freePagePool(wrapUnique(new FreePagePool))
     , m_orphanedPagePool(wrapUnique(new OrphanedPagePool))
     , m_markingStack(wrapUnique(new CallbackStack()))

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

Let's add CallbackStack::create() ?

     , m_postMarkingCallbackStack(wrapUnique(new CallbackStack()))
     , m_globalWeakCallbackStack(wrapUnique(new CallbackStack()))
-    , m_ephemeronStack(wrapUnique(new CallbackStack(CallbackStack::kMinimalBlockSize)))
+    , m_ephemeronStack(wrapUnique(new CallbackStack()))
 {
     if (ThreadState::current()->isMainThread())
         s_mainThreadHeap = this;
 
     MutexLocker locker(ThreadHeap::allHeapsMutex());
     allHeaps().add(this);
 }
 
 ThreadHeap::~ThreadHeap()
 {
@@ skipping 188 matching lines @@
 }
 
 #if ENABLE(ASSERT)
 bool ThreadHeap::weakTableRegistered(const void* table)
 {
     ASSERT(m_ephemeronStack);
     return m_ephemeronStack->hasCallbackForObject(table);
 }
 #endif
 
+void ThreadHeap::commitCallbackStacks()
+{
+    m_markingStack->commit();
+    m_postMarkingCallbackStack->commit();
+    m_globalWeakCallbackStack->commit();
+    m_ephemeronStack->commit();
+}
+
 void ThreadHeap::decommitCallbackStacks()
 {
     m_markingStack->decommit();
     m_postMarkingCallbackStack->decommit();
     m_globalWeakCallbackStack->decommit();
     m_ephemeronStack->decommit();
 }
 
 void ThreadHeap::preGC()
 {
@@ skipping 58 matching lines @@
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
     double startTime = WTF::currentTimeMS();
 
     if (gcType == BlinkGC::TakeSnapshot)
         BlinkGCMemoryDumpProvider::instance()->clearProcessDumpForCurrentGC();
 
     // Disallow allocation during garbage collection (but not during the
     // finalization that happens when the visitorScope is torn down).
     ThreadState::NoAllocationScope noAllocationScope(state);
 
+    state->heap().commitCallbackStacks();
     state->heap().preGC();
 
     StackFrameDepthScope stackDepthScope;
 
     size_t totalObjectSize = state->heap().heapStats().allocatedObjectSize() + state->heap().heapStats().markedObjectSize();
     if (gcType != BlinkGC::TakeSnapshot)
         state->heap().resetHeapCounters();
 
     {
         // Access to the CrossThreadPersistentRegion has to be prevented while
@@ skipping 51 matching lines @@
 {
     {
         // A thread-specific termination GC must not allow other global GCs to go
         // ahead while it is running, hence the termination GC does not enter a
         // safepoint. VisitorScope will not enter also a safepoint scope for
         // ThreadTerminationGC.
         std::unique_ptr<Visitor> visitor = Visitor::create(state, BlinkGC::ThreadTerminationGC);
 
         ThreadState::NoAllocationScope noAllocationScope(state);
 
+        state->heap().commitCallbackStacks();
         state->preGC();
 
         // 1. Trace the thread local persistent roots. For thread local GCs we
         // don't trace the stack (ie. no conservative scanning) since this is
         // only called during thread shutdown where there should be no objects
         // on the stack.
         // We also assume that orphaned pages have no objects reachable from
         // persistent handles on other threads or CrossThreadPersistents.  The
         // only cases where this could happen is if a subsequent conservative
         // global GC finds a "pointer" on the stack or due to a programming
@@ skipping 198 matching lines @@
     ProcessHeap::decreaseTotalMarkedObjectSize(m_stats.markedObjectSize());
 
     m_stats.reset();
     for (ThreadState* state : m_threads)
         state->resetHeapCounters();
 }
 
 ThreadHeap* ThreadHeap::s_mainThreadHeap = nullptr;
 
 } // namespace blink