Oilpan: Decommit backing storage of 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 337 matching lines @@
 }
 
 #if ENABLE(ASSERT)
 bool Heap::weakTableRegistered(const void* table)
 {
     ASSERT(s_ephemeronStack);
     return s_ephemeronStack->hasCallbackForObject(table);
 }
 #endif
 
+void Heap::decommitCallbackStacks()
+{
+    s_markingStack->decommit();

[sof, 2016/02/24 09:29:39]

An alternative scheme would be for Heap to reserve memory for all the initial
CallbackStacks in one chunk & then create the stacks with initial blocks set up
to offset into that reserved block.

That way you could decommit the chunk in one operation, and free
CallbackStack::Block from having to decommit themselves individually. Any extra
blocks needed by a CallbackStack would then not be allocated in
"decommittable-memory", which is "fine" (assuming any allocation like this is
acceptable during marking) as they'll be deallocated shortly thereafter anyway.

+    s_postMarkingCallbackStack->decommit();
+    s_globalWeakCallbackStack->decommit();
+    s_ephemeronStack->decommit();
+}
+
 void Heap::preGC()
 {
     ASSERT(!ThreadState::current()->isInGC());
     for (ThreadState* state : ThreadState::attachedThreads())
         state->preGC();
 }
 
 void Heap::postGC(BlinkGC::GCType gcType)
 {
     ASSERT(ThreadState::current()->isInGC());
@@ skipping 94 matching lines @@
     totalObjectSpaceHistogram.count(Heap::allocatedObjectSize() / 1024);
     DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, totalAllocatedSpaceHistogram, new CustomCountHistogram("BlinkGC.TotalAllocatedSpace", 0, 4 * 1024 * 1024, 50));
     totalAllocatedSpaceHistogram.count(Heap::allocatedSpace() / 1024);
     DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, gcReasonHistogram, new EnumerationHistogram("BlinkGC.GCReason", BlinkGC::NumberOfGCReason));
     gcReasonHistogram.count(reason);
 
     Heap::reportMemoryUsageHistogram();
     WTF::Partitions::reportMemoryUsageHistogram();
 
     postGC(gcType);
+    Heap::decommitCallbackStacks();
 
 #if ENABLE(ASSERT)
     // 0 is used to figure non-assigned area, so avoid to use 0 in s_gcGeneration.
     if (++s_gcGeneration == 0) {
         s_gcGeneration = 1;
     }
 #endif
 }
 
 void Heap::collectGarbageForTerminatingThread(ThreadState* state)
@@ skipping 22 matching lines @@
         state->visitPersistents(gcScope.visitor());
 
         // 2. Trace objects reachable from the thread's persistent roots
         // including ephemerons.
         processMarkingStack(gcScope.visitor());
 
         postMarkingProcessing(gcScope.visitor());
         globalWeakProcessing(gcScope.visitor());
 
         state->postGC(BlinkGC::GCWithSweep);
+        Heap::decommitCallbackStacks();
     }
     state->preSweep();
 }
 
 void Heap::processMarkingStack(Visitor* visitor)
 {
     // Ephemeron fixed point loop.
     do {
         {
             // Iteratively mark all objects that are reachable from the objects
@@ skipping 16 matching lines @@
 void Heap::postMarkingProcessing(Visitor* visitor)
 {
     TRACE_EVENT0("blink_gc", "Heap::postMarkingProcessing");
     // Call post-marking callbacks including:
     // 1. the ephemeronIterationDone callbacks on weak tables to do cleanup
     //    (specifically to clear the queued bits for weak hash tables), and
     // 2. the markNoTracing callbacks on collection backings to mark them
     //    if they are only reachable from their front objects.
     while (popAndInvokePostMarkingCallback(visitor)) { }
 
-    s_ephemeronStack->clear();
-
     // Post-marking callbacks should not trace any objects and
     // therefore the marking stack should be empty after the
     // post-marking callbacks.
     ASSERT(s_markingStack->isEmpty());
 }
 
 void Heap::globalWeakProcessing(Visitor* visitor)
 {
     TRACE_EVENT0("blink_gc", "Heap::globalWeakProcessing");
     double startTime = WTF::currentTimeMS();
@@ skipping 164 matching lines @@
 size_t Heap::s_wrapperCountAtLastGC = 0;
 size_t Heap::s_collectedWrapperCount = 0;
 size_t Heap::s_partitionAllocSizeAtLastGC = 0;
 double Heap::s_estimatedMarkingTimePerByte = 0.0;
 bool Heap::s_isLowEndDevice = false;
 #if ENABLE(ASSERT)
 uint16_t Heap::s_gcGeneration = 0;
 #endif
 
 } // namespace blink