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

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 460 matching lines @@
 void ThreadState::detach()
 {
     ThreadState* state = current();
     state->cleanup();
     delete state;
     shutdownHeapIfNecessary();
 }
 
 void ThreadState::visitPersistentRoots(Visitor* visitor)
 {
+    TRACE_EVENT0("blink_gc", "ThreadState::visitPersistentRoots");
     {
         // All threads are at safepoints so this is not strictly necessary.
         // However we acquire the mutex to make mutation and traversal of this
         // list symmetrical.
         MutexLocker locker(globalRootsMutex());
         globalRoots()->trace(visitor);
     }
 
     AttachedThreadStateSet& threads = attachedThreads();
     for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->visitPersistents(visitor);
 }
 
 void ThreadState::visitStackRoots(Visitor* visitor)
 {
+    TRACE_EVENT0("blink_gc", "ThreadState::visitStackRoots");
     AttachedThreadStateSet& threads = attachedThreads();
     for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->visitStack(visitor);
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitAsanFakeStackForPointer(Visitor* visitor, Address ptr)
 {
 #if defined(ADDRESS_SANITIZER)
     Address* start = reinterpret_cast<Address*>(m_startOfStack);
@@ skipping 583 matching lines @@
         ScriptForbiddenScope::enter();
         TRACE_EVENT_SET_SAMPLING_STATE("blink", "BlinkGCSweeping");
     }
 
     size_t objectSpaceBeforeSweep = m_stats.totalObjectSpace();
     {
         NoSweepScope scope(this);
 
         // Disallow allocation during weak processing.
         enterNoAllocationScope();
-        // Perform thread-specific weak processing.
-        while (popAndInvokeWeakPointerCallback(Heap::s_markingVisitor)) { }
+        {
+            TRACE_EVENT0("blink_gc", "ThreadState::threadLocalWeakProcessing");
+            // Perform thread-specific weak processing.
+            while (popAndInvokeWeakPointerCallback(Heap::s_markingVisitor)) { }
+        }
         leaveNoAllocationScope();
 
         // Perform sweeping and finalization.
 
         // Sweeping will recalculate the stats
         m_stats.clear();
 
         // Sweep the non-finalized heap pages on multiple threads.
         // Attempt to load-balance by having the sweeper thread sweep as
         // close to half of the pages as possible.
@@ skipping 24 matching lines @@
                 // sweeper thread and the owner thread.
                 int pagesToSplitOff = std::min(pageCount, pagesToSweepInParallel);
                 pagesToSweepInParallel -= pagesToSplitOff;
                 BaseHeap* splitOff = heap->split(pagesToSplitOff);
                 splitOffHeaps[i] = splitOff;
                 HeapStats* stats = &heapStatsVector[i];
                 m_sweeperThread->postTask(new SweepNonFinalizedHeapTask(this, splitOff, stats));
             }
         }
 
-        // Sweep the remainder of the non-finalized pages (or all of them
-        // if there is no sweeper thread).
-        for (int i = 0; i < NumberOfNonFinalizedHeaps; i++) {
-            HeapStats stats;
-            m_heaps[FirstNonFinalizedHeap + i]->sweep(&stats);
-            m_stats.add(&stats);
+        {
+            // Sweep the remainder of the non-finalized pages (or all of them
+            // if there is no sweeper thread).
+            TRACE_EVENT0("blink_gc", "ThreadState::sweepNonFinalizedHeaps");
+            for (int i = 0; i < NumberOfNonFinalizedHeaps; i++) {
+                HeapStats stats;
+                m_heaps[FirstNonFinalizedHeap + i]->sweep(&stats);
+                m_stats.add(&stats);
+            }
         }
 
-        // Sweep the finalized pages.
-        for (int i = 0; i < NumberOfFinalizedHeaps; i++) {
-            HeapStats stats;
-            m_heaps[FirstFinalizedHeap + i]->sweep(&stats);
-            m_stats.add(&stats);
+        {
+            // Sweep the finalized pages.
+            TRACE_EVENT0("blink_gc", "ThreadState::sweepFinalizedHeaps");
+            for (int i = 0; i < NumberOfFinalizedHeaps; i++) {
+                HeapStats stats;
+                m_heaps[FirstFinalizedHeap + i]->sweep(&stats);
+                m_stats.add(&stats);
+            }
         }
 
         // Wait for the sweeper threads and update the heap stats with the
         // stats for the heap portions swept by those threads.
         waitUntilSweepersDone();
         for (int i = 0; i < NumberOfNonFinalizedHeaps; i++) {
             m_stats.add(&heapStatsVector[i]);
             if (BaseHeap* splitOff = splitOffHeaps[i])
                 m_heaps[FirstNonFinalizedHeap + i]->merge(splitOff);
         }
@@ skipping 72 matching lines @@
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 
 }