Try reducing and balance GC callback stack sizes.

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 1944 matching lines @@
 }
 
 void Heap::flushHeapDoesNotContainCache()
 {
     s_heapDoesNotContainCache->flush();
 }
 
 void Heap::init()
 {
     ThreadState::init();
-    s_markingStack = new CallbackStack();
-    s_postMarkingCallbackStack = new CallbackStack();
-    s_weakCallbackStack = new CallbackStack();
-    s_ephemeronStack = new CallbackStack();
+    s_markingVisitor = new MarkingVisitor<Visitor::GlobalMarking>();
     s_heapDoesNotContainCache = new HeapDoesNotContainCache();
-    s_markingVisitor = new MarkingVisitor<Visitor::GlobalMarking>();
     s_freePagePool = new FreePagePool();
     s_orphanedPagePool = new OrphanedPagePool();
-    s_allocatedObjectSize = 0;
-    s_allocatedSpace = 0;
-    s_markedObjectSize = 0;
-    s_estimatedMarkingTimePerByte = 0.0;
 
     GCInfoTable::init();
 }
 
 void Heap::shutdown()
 {
     s_shutdownCalled = true;
     ThreadState::shutdownHeapIfNecessary();
 }
 
@@ skipping 265 matching lines @@
     double timeStamp = WTF::currentTimeMS();
 #if ENABLE(GC_PROFILING)
     static_cast<MarkingVisitor<Visitor::GlobalMarking>*>(s_markingVisitor)->objectGraph().clear();
 #endif
 
     // Disallow allocation during garbage collection (but not during the
     // finalization that happens when the gcScope is torn down).
     ThreadState::NoAllocationScope noAllocationScope(state);
 
     preGC();
+    Heap::ensureCallbackStacks();
     StackFrameDepth::configureStackLimit();
     ASSERT(StackFrameDepth::isSafeToRecurse());
 
     size_t totalObjectSize = Heap::allocatedObjectSize() + Heap::markedObjectSize();
     Heap::resetHeapCounters();
 
     // 1. Trace persistent roots.
     ThreadState::visitPersistentRoots(s_markingVisitor);
 
     // 2. Trace objects reachable from the persistent roots including
@@ skipping 41 matching lines @@
 void Heap::collectGarbageForTerminatingThread(ThreadState* state)
 {
     // We explicitly do not enter a safepoint while doing thread specific
     // garbage collection since we don't want to allow a global GC at the
     // same time as a thread local GC.
     {
         MarkingVisitor<Visitor::ThreadLocalMarking> markingVisitor;
         ThreadState::NoAllocationScope noAllocationScope(state);
 
         state->preGC();
+        Heap::ensureCallbackStacks();
         StackFrameDepth::configureStackLimit();
         ASSERT(StackFrameDepth::isSafeToRecurse());
 
         // 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
@@ skipping 334 matching lines @@
 
 void Heap::resetHeapCounters()
 {
     ASSERT(ThreadState::current()->isInGC());
 
     s_allocatedObjectSize = 0;
     s_markedObjectSize = 0;
     s_externalObjectSizeAtLastGC = WTF::Partitions::totalSizeOfCommittedPages();
 }
 
+void Heap::ensureCallbackStacks()
+{
+    if (s_markingStack)
+        return;
+
+    s_markingStack = new CallbackStack(CallbackStack::MarkingStackBlockSize);
+    s_postMarkingCallbackStack = new CallbackStack(CallbackStack::PostMarkingStackBlockSize);
+    s_weakCallbackStack = new CallbackStack(CallbackStack::WeakCallbackStackBlockSize);
+    s_ephemeronStack = new CallbackStack(CallbackStack::EphemeronCallbackStackBlockSize);
+}
+
 Visitor* Heap::s_markingVisitor;
-CallbackStack* Heap::s_markingStack;
-CallbackStack* Heap::s_postMarkingCallbackStack;
-CallbackStack* Heap::s_weakCallbackStack;
-CallbackStack* Heap::s_ephemeronStack;
+CallbackStack* Heap::s_markingStack = nullptr;
+CallbackStack* Heap::s_postMarkingCallbackStack = nullptr;
+CallbackStack* Heap::s_weakCallbackStack = nullptr;
+CallbackStack* Heap::s_ephemeronStack = nullptr;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 // We don't want to use 0 KB for the initial value because it may end up
 // triggering the first GC of some thread too prematurely.
 size_t Heap::s_estimatedLiveObjectSize = 512 * 1024;
 size_t Heap::s_externalObjectSizeAtLastGC = 0;
 double Heap::s_estimatedMarkingTimePerByte = 0.0;
 
 } // namespace blink