Oilpan: Add trace events for the GC marking and sweeping phases.

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 1228 matching lines @@
     for (HeapPage<Header>* page = m_firstPage; page; page = page->next())
         page->getStats(scannedStats);
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next())
         current->getStats(scannedStats);
 }
 #endif
 
 template<typename Header>
 void ThreadHeap<Header>::sweepNormalPages(HeapStats* stats)
 {
+    TRACE_EVENT0("blink_gc", "ThreadHeap::sweepNormalPages");
     HeapPage<Header>* page = m_firstPage;
     HeapPage<Header>** previousNext = &m_firstPage;
     HeapPage<Header>* previous = 0;
     while (page) {
         page->resetPromptlyFreedSize();
         if (page->isEmpty()) {
             HeapPage<Header>* unused = page;
             if (unused == m_mergePoint)
                 m_mergePoint = previous;
             page = page->next();
             HeapPage<Header>::unlink(this, unused, previousNext);
             --m_numberOfNormalPages;
         } else {
             page->sweep(stats, this);
             previousNext = &page->m_next;
             previous = page;
             page = page->next();
         }
     }
 }
 
 template<typename Header>
 void ThreadHeap<Header>::sweepLargePages(HeapStats* stats)
 {
+    TRACE_EVENT0("blink_gc", "ThreadHeap::sweepLargePages");
     LargeHeapObject<Header>** previousNext = &m_firstLargeHeapObject;
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current;) {
         if (current->isMarked()) {
             stats->increaseAllocatedSpace(current->size());
             stats->increaseObjectSpace(current->payloadSize());
             current->unmark();
             previousNext = &current->m_next;
             current = current->next();
         } else {
             LargeHeapObject<Header>* next = current->next();
@@ skipping 1171 matching lines @@
 #endif
 
 void Heap::prepareForGC()
 {
     ASSERT(ThreadState::isAnyThreadInGC());
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->prepareForGC();
 }
 
-void Heap::collectGarbage(ThreadState::StackState stackState)
+void Heap::collectGarbage(ThreadState::StackState stackState, ThreadState::CauseOfGC cause)
 {
     ThreadState* state = ThreadState::current();
     state->clearGCRequested();
 
     GCScope gcScope(stackState);
     // Check if we successfully parked the other threads. If not we bail out of the GC.
     if (!gcScope.allThreadsParked()) {
         ThreadState::current()->setGCRequested();
         return;
     }
 
     if (state->isMainThread())
         ScriptForbiddenScope::enter();
 
     s_lastGCWasConservative = false;
 
-    TRACE_EVENT0("blink_gc", "Heap::collectGarbage");
+    TRACE_EVENT2("blink_gc", "Heap::collectGarbage",
+        "precise", stackState == ThreadState::NoHeapPointersOnStack,
+        "forced", cause == ThreadState::ForcedGC);
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
     double timeStamp = WTF::currentTimeMS();
 #if ENABLE(GC_PROFILE_MARKING)
     static_cast<MarkingVisitor*>(s_markingVisitor)->objectGraph().clear();
 #endif
 
     // Disallow allocation during garbage collection (but not
     // during the finalization that happens when the gcScope is
     // torn down).
     NoAllocationScope<AnyThread> noAllocationScope;
@@ skipping 76 matching lines @@
         postMarkingProcessing();
         globalWeakProcessing();
 
         state->leaveGC();
     }
     state->performPendingSweep();
 }
 
 void Heap::processMarkingStackEntries(int* runningMarkingThreads)
 {
+    TRACE_EVENT0("blink_gc", "Heap::processMarkingStackEntries");
     CallbackStack* stack = 0;
     MarkingVisitor visitor(&stack);
     {
         MutexLocker locker(markingMutex());
         stack = s_markingStack->takeCallbacks(&s_markingStack);
     }
     while (stack) {
         while (stack->popAndInvokeCallback<GlobalMarking>(&stack, &visitor)) { }
         delete stack;
         {
@@ skipping 27 matching lines @@
 {
     static const int numberOfBlocksForParallelMarking = 2;
     // Ephemeron fixed point loop run on the garbage collecting thread.
     do {
         // Iteratively mark all objects that are reachable from the objects
         // currently pushed onto the marking stack. Do so in parallel if there
         // are multiple blocks on the global marking stack.
         if (s_markingStack->numberOfBlocksExceeds(numberOfBlocksForParallelMarking)) {
             processMarkingStackOnMultipleThreads();
         } else {
+            TRACE_EVENT0("blink_gc", "Heap::processMarkingStackSingleThreaded");
             while (popAndInvokeTraceCallback<GlobalMarking>(s_markingVisitor)) { }
         }
 
         // Mark any strong pointers that have now become reachable in ephemeron
         // maps.
+        TRACE_EVENT0("blink_gc", "Heap::processEphemeronStack");
         CallbackStack::invokeCallbacks(&s_ephemeronStack, s_markingVisitor);
 
         // Rerun loop if ephemeron processing queued more objects for tracing.
     } while (!s_markingStack->isEmpty());
 }
 
 template<CallbackInvocationMode Mode>
 void Heap::processMarkingStack()
 {
     // Ephemeron fixed point loop.
     do {
         // Iteratively mark all objects that are reachable from the objects
         // currently pushed onto the marking stack. If Mode is ThreadLocalMarking
         // don't continue tracing if the trace hits an object on another thread's
         // heap.
+        TRACE_EVENT0("blink_gc", "Heap::processMarkingStackSingleThreaded");
         while (popAndInvokeTraceCallback<Mode>(s_markingVisitor)) { }
 
         // Mark any strong pointers that have now become reachable in ephemeron
         // maps.
+        TRACE_EVENT0("blink_gc", "Heap::processEphemeronStack");
         CallbackStack::invokeCallbacks(&s_ephemeronStack, s_markingVisitor);
 
         // Rerun loop if ephemeron processing queued more objects for tracing.
     } while (!s_markingStack->isEmpty());
 }
 
 void Heap::postMarkingProcessing()
 {
+    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(s_markingVisitor)) { }
 
     CallbackStack::clear(&s_ephemeronStack);
 
     // 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()
 {
+    TRACE_EVENT0("blink_gc", "Heap::globalWeakProcessing");
     // Call weak callbacks on objects that may now be pointing to dead
     // objects.
     while (popAndInvokeWeakPointerCallback(s_markingVisitor)) { }
 
     // It is not permitted to trace pointers of live objects in the weak
     // callback phase, so the marking stack should still be empty here.
     ASSERT(s_markingStack->isEmpty());
 }
 
 void Heap::collectAllGarbage()
 {
     // FIXME: oilpan: we should perform a single GC and everything
     // should die. Unfortunately it is not the case for all objects
     // because the hierarchy was not completely moved to the heap and
     // some heap allocated objects own objects that contain persistents
     // pointing to other heap allocated objects.
     for (int i = 0; i < 5; i++)
-        collectGarbage(ThreadState::NoHeapPointersOnStack);
+        collectGarbage(ThreadState::NoHeapPointersOnStack, ThreadState::ForcedGC);
 }
 
 void Heap::setForcePreciseGCForTesting()
 {
     ThreadState::current()->setForcePreciseGCForTesting(true);
 }
 
 template<typename Header>
 void ThreadHeap<Header>::prepareHeapForTermination()
 {
@@ skipping 143 matching lines @@
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_postMarkingCallbackStack;
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 }