Add UMAs about Blink GC metrics

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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/heap/ThreadState.h"
 
 #include "platform/TraceEvent.h"
 #include "platform/heap/AddressSanitizer.h"
 #include "platform/heap/Handle.h"
 #include "platform/heap/Heap.h"
+#include "public/platform/Platform.h"
 #include "wtf/ThreadingPrimitives.h"
 
 #if OS(WIN)
 #include <stddef.h>
 #include <windows.h>
 #include <winnt.h>
 #elif defined(__GLIBC__)
 extern "C" void* __libc_stack_end;  // NOLINT
 #endif
 
@@ skipping 764 matching lines @@
     }
 }
 
 void ThreadState::performPendingSweep()
 {
     if (!sweepRequested())
         return;
 
     TRACE_EVENT0("Blink", "ThreadState::performPendingSweep");
     const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
-    if (isMainThread())
+    double timeStamp = 0;
+    if (isMainThread()) {
         TRACE_EVENT_SET_SAMPLING_STATE("Blink", "BlinkGCSweeping");
+        timeStamp = WTF::currentTimeMS();

[Mads Ager (chromium), 2014/05/28 09:35:45]

Is histogram collection also not thread safe? It would have been nice if we
could have histograms for all sweeps (also the ones not on the main thread).

[haraken, 2014/05/28 09:40:15]

It's thread-safe.

At first, I thought that if we collect sweeping time from other threads
(workers, database threads etc), the histogram distribution might be biased by
those non-main threads which will allocate very little objects. So I thought it
might be better to limit the UMA to the main thread.

Either is fine with me.

[haraken, 2014/05/28 10:40:26]

Done.

+    }
 
     m_sweepInProgress = true;
     // Disallow allocation during weak processing.
     enterNoAllocationScope();
     // Perform thread-specific weak processing.
     while (popAndInvokeWeakPointerCallback(Heap::s_markingVisitor)) { }
     leaveNoAllocationScope();
     // Perform sweeping and finalization.
     m_stats.clear(); // Sweeping will recalculate the stats
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->sweep();
     getStats(m_statsAfterLastGC);
     m_sweepInProgress = false;
     clearGCRequested();
     clearSweepRequested();
 
-    if (isMainThread())
+    if (isMainThread()) {
         TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
+        if (blink::Platform::current()) {
+            blink::Platform::current()->histogramEnumeration("BlinkGC.PerformPendingSweep", WTF::currentTimeMS() - timeStamp, 30000);
+        }
+    }
 }
 
 void ThreadState::addInterruptor(Interruptor* interruptor)
 {
     SafePointScope scope(HeapPointersOnStack, SafePointScope::AllowNesting);
 
     {
         MutexLocker locker(threadAttachMutex());
         m_interruptors.append(interruptor);
     }
@@ skipping 19 matching lines @@
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }