Oilpan: Implement a GC to take a heap snapshot

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 820 matching lines @@
 }
 
 void ThreadState::flushHeapDoesNotContainCacheIfNeeded()
 {
     if (m_shouldFlushHeapDoesNotContainCache) {
         Heap::flushHeapDoesNotContainCache();
         m_shouldFlushHeapDoesNotContainCache = false;
     }
 }
 
-void ThreadState::makeConsistentForSweeping()
+void ThreadState::makeConsistentForSweeping(GCType gcType)
 {
     ASSERT(isInGC());
     TRACE_EVENT0("blink_gc", "ThreadState::makeConsistentForSweeping");
     for (int i = 0; i < NumberOfHeaps; ++i)
-        m_heaps[i]->makeConsistentForSweeping();
+        m_heaps[i]->makeConsistentForSweeping(gcType);
 }
 
-void ThreadState::preGC()
+void ThreadState::preGC(GCType gcType)
 {
     ASSERT(!isInGC());
     setGCState(GCRunning);
-    makeConsistentForSweeping();
+    makeConsistentForSweeping(gcType);
     prepareRegionTree();
     flushHeapDoesNotContainCacheIfNeeded();
     clearHeapAges();
 }
 
 void ThreadState::postGC(GCType gcType)
 {
     ASSERT(isInGC());
 
 #if ENABLE(GC_PROFILING)
     // We snapshot the heap prior to sweeping to get numbers for both resources
     // that have been allocated since the last GC and for resources that are
     // going to be freed.
     bool gcTracingEnabled;
     TRACE_EVENT_CATEGORY_GROUP_ENABLED("blink_gc", &gcTracingEnabled);
 
     if (gcTracingEnabled) {
         bool disabledByDefaultGCTracingEnabled;
         TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("blink_gc"), &disabledByDefaultGCTracingEnabled);
 
         snapshot();
         if (disabledByDefaultGCTracingEnabled)
             collectAndReportMarkSweepStats();
         incrementMarkedObjectsAge();
     }
 #endif
 
-    setGCState(gcType == GCWithSweep ? EagerSweepScheduled : LazySweepScheduled);
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->prepareForSweep();
+
+    if (gcType == GCWithSweep) {
+        setGCState(EagerSweepScheduled);
+    } else if (gcType == GCWithoutSweep) {
+        setGCState(LazySweepScheduled);
+    } else {
+        takeSnapshot();

[ssid, 2015/05/27 12:43:47]

Sorry, I just realized. This takeSnapshot() should be called before
prepareForSweep().
Also, should prepareForSweep() be called for a GC without sweeping? I see this
method moves pages to other list. Will this be undone?
In any case, i think this should be before the call.

[haraken, 2015/05/27 13:48:10]

prepareForSweep() needs to be called, because the following
makeConsistentForSweeping() works only on the list of unswept pages. If we don't
call prepareForSweep(), all pages are in the list of swept pages and thus we'll
fail at unmarking the marked objects etc.

It is possible to move prepareForSweep() to after takeSnapshot(), but it won't
matter much. If we don't move it, takeSnapshot() needs to scan the list of
unswept pages. If we move it, takeSnapshot() needs to scan the list of swept
pages. That's the only difference, I guess.

+        // This unmarks all marked objects and marks all unmarked objects dead.
+        makeConsistentForSweeping(gcType);
+        // Force setting NoGCScheduled to circumvent checkThread()
+        // in setGCState().
+        m_gcState = NoGCScheduled;
+    }
 }
 
 void ThreadState::preSweep()
 {
     checkThread();
     if (gcState() != EagerSweepScheduled && gcState() != LazySweepScheduled)
         return;
 
     {
         if (isMainThread())
@@ skipping 364 matching lines @@
         m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(Vector1HeapIndex, Vector4HeapIndex);
 }
 
 void ThreadState::promptlyFreed(size_t gcInfoIndex)
 {
     size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
     // See the comment in vectorBackingHeap() for why this is +3.
     m_likelyToBePromptlyFreed[entryIndex] += 3;
 }
 
+void ThreadState::takeSnapshot()
+{
+    ASSERT(isInGC());
+    // TODO(ssid): Implement this.
+}
+
 #if ENABLE(GC_PROFILING)
 const GCInfo* ThreadState::findGCInfoFromAllThreads(Address address)
 {
     bool needLockForIteration = !ThreadState::current()->isInGC();
     if (needLockForIteration)
         threadAttachMutex().lock();
 
     for (ThreadState* state : attachedThreads()) {
         if (const GCInfo* gcInfo = state->findGCInfo(address)) {
             if (needLockForIteration)
@@ skipping 70 matching lines @@
         json->beginArray(it->key.ascii().data());
         for (size_t age = 0; age <= maxHeapObjectAge; ++age)
             json->pushInteger(it->value.ages[age]);
         json->endArray();
     }
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), statsName, this, json.release());
 }
 #endif
 
 } // namespace blink