Oilpan: Trace Heap memory statistics more often.

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 427 matching lines @@
     TRACE_EVENT0("blink_gc", "BaseHeap::lazySweepPages");
     ThreadState::SweepForbiddenScope scope(threadState());
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::enter();
 
     Address result = lazySweepPages(allocationSize, gcInfoIndex);
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
+
+    Heap::reportMemoryUsageForTracing();
+
     return result;
 }
 
 void BaseHeap::sweepUnsweptPage()
 {
     BasePage* page = m_firstUnsweptPage;
     if (page->isEmpty()) {
         page->unlink(&m_firstUnsweptPage);
         page->removeFromHeap();
     } else {
@@ skipping 16 matching lines @@
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
     ASSERT(threadState()->sweepForbidden());
     ASSERT(!threadState()->isMainThread() || ScriptForbiddenScope::isScriptForbidden());
 
     int pageCount = 1;
     while (m_firstUnsweptPage) {
         sweepUnsweptPage();
         if (pageCount % deadlineCheckInterval == 0) {
             if (deadlineSeconds <= Platform::current()->monotonicallyIncreasingTime()) {
                 // Deadline has come.
+                Heap::reportMemoryUsageForTracing();
                 return !m_firstUnsweptPage;
             }
         }
         pageCount++;
     }
+    Heap::reportMemoryUsageForTracing();
     return true;
 }
 
 void BaseHeap::completeSweep()
 {
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
     ASSERT(threadState()->sweepForbidden());
     ASSERT(!threadState()->isMainThread() || ScriptForbiddenScope::isScriptForbidden());
 
     while (m_firstUnsweptPage) {
         sweepUnsweptPage();
     }
+
+    Heap::reportMemoryUsageForTracing();

[haraken, 2015/06/22 04:28:51]

I think it's better to put Heap::reportMemoryUsageForTracing() in
ThreadState::XXX instead of BaseHeap::XXX. BaseHeap::XXX is called multiple
times (it's called for each heap) by ThreadState::XXX, so you will end up
printing the traced values multiple times.

The same comment for other Heap::reportMemoryUsageForTracing()s in Heap.cpp.

[Yuta Kitamura, 2015/06/22 08:31:52]

Correct me if I'm wrong, but I think no ThreadState method
is called during BaseHeap::lazySweep() or lazySweepPages().

This patch's point is that I want to look at the value changes
while lazy sweep is in progress. I'd like to capture the cases
where NormalPageHeap::outOfLineAllocate() exits before it
reaches step 6 (threadState()->completeSweep()). I don't think
there is a chance for ThreadState to be able to hook something
for cases where outOfLineAllocate() returns in step 4 or 5.

(With that said, these reportMemoryUsageForTracing() calls
may certainly be redundant; I may be able to remove these
calls in Heap.cpp.)

 }
 
 NormalPageHeap::NormalPageHeap(ThreadState* state, int index)
     : BaseHeap(state, index)
     , m_currentAllocationPoint(nullptr)
     , m_remainingAllocationSize(0)
     , m_lastRemainingAllocationSize(0)
     , m_promptlyFreedSize(0)
 #if ENABLE(GC_PROFILING)
     , m_cumulativeAllocationSize(0)
@@ skipping 1672 matching lines @@
     if (sizeInMB >= supportedMaxSizeInMB)
         sizeInMB = supportedMaxSizeInMB - 1;
     if (sizeInMB > observedMaxSizeInMB) {
         // Send a UseCounter only when we see the highest memory usage
         // we've ever seen.
         Platform::current()->histogramEnumeration("BlinkGC.CommittedSize", sizeInMB, supportedMaxSizeInMB);
         observedMaxSizeInMB = sizeInMB;
     }
 }
 
+#if ENABLE(GC_PROFILING)
+void Heap::reportMemoryUsageForTracing()
+{
+    // These values are divided by 1024 to avoid overflow in practical cases (TRACE_COUNTER values are 32-bit ints).
+    // They are capped to INT_MAX just in case.
+    TRACE_COUNTER1("blink_gc", "Heap::estimatedLiveObjectSizeKB", std::min(Heap::estimatedLiveObjectSize() / 1024, static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "Heap::allocatedObjectSizeKB", std::min(Heap::allocatedObjectSize() / 1024, static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "Heap::markedObjectSizeKB", std::min(Heap::markedObjectSize() / 1024, static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "Partitions::totalSizeOfCommittedPagesKB", std::min(WTF::Partitions::totalSizeOfCommittedPages() / 1024, static_cast<size_t>(INT_MAX)));
+}
+#endif
+
 size_t Heap::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
     for (ThreadState* state : ThreadState::attachedThreads()) {
         state->setGCState(ThreadState::GCRunning);
         state->makeConsistentForGC();
         objectPayloadSize += state->objectPayloadSizeForTesting();
         state->setGCState(ThreadState::EagerSweepScheduled);
         state->setGCState(ThreadState::Sweeping);
         state->setGCState(ThreadState::NoGCScheduled);
@@ skipping 113 matching lines @@
 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