Oilpan: Implement a GC to take a heap snapshot

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 281 matching lines @@
     }
     if (previousPage) {
         ASSERT(m_firstUnsweptPage);
         previousPage->m_next = m_firstPage;
         m_firstPage = m_firstUnsweptPage;
         m_firstUnsweptPage = nullptr;
     }
     ASSERT(!m_firstUnsweptPage);
 }
 
+void BaseHeap::makeConsistentForMutator()
+{
+    clearFreeLists();
+    ASSERT(isConsistentForGC());
+    ASSERT(!m_firstPage);
+
+    // Drop marks from marked objects and rebuild free lists in preparation for
+    // resuming the executions of mutators.
+    BasePage* previousPage = nullptr;
+    for (BasePage* page = m_firstUnsweptPage; page; previousPage = page, page = page->next()) {
+        page->makeConsistentForMutator();
+        page->markAsSwept();
+    }
+    if (previousPage) {
+        ASSERT(m_firstUnsweptPage);
+        previousPage->m_next = m_firstPage;
+        m_firstPage = m_firstUnsweptPage;
+        m_firstUnsweptPage = nullptr;
+    }
+    ASSERT(!m_firstUnsweptPage);
+}
+
 size_t BaseHeap::objectPayloadSizeForTesting()
 {
     ASSERT(isConsistentForGC());
     ASSERT(!m_firstUnsweptPage);
 
     size_t objectPayloadSize = 0;
     for (BasePage* page = m_firstPage; page; page = page->next())
         objectPayloadSize += page->objectPayloadSizeForTesting();
     return objectPayloadSize;
 }
 
 void BaseHeap::prepareHeapForTermination()
 {
     ASSERT(!m_firstUnsweptPage);
     for (BasePage* page = m_firstPage; page; page = page->next()) {
         page->setTerminating();
     }
 }
 
 void BaseHeap::prepareForSweep()
 {
-    ASSERT(!threadState()->isInGC());
+    ASSERT(threadState()->isInGC());
     ASSERT(!m_firstUnsweptPage);
 
     // Move all pages to a list of unswept pages.
     m_firstUnsweptPage = m_firstPage;
     m_firstPage = nullptr;
 }
 
 #if defined(ADDRESS_SANITIZER)
 void BaseHeap::poisonUnmarkedObjects()
 {
@@ skipping 838 matching lines @@
             markedObjectSize += header->size();
         } else {
             header->markDead();
         }
         headerAddress += header->size();
     }
     if (markedObjectSize)
         Heap::increaseMarkedObjectSize(markedObjectSize);
 }
 
+void NormalPage::makeConsistentForMutator()
+{
+    size_t markedObjectSize = 0;
+    Address startOfGap = payload();
+    for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
+        HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
+        ASSERT(header->size() < blinkPagePayloadSize());
+        // Check if a free list entry first since we cannot call
+        // isMarked on a free list entry.
+        if (header->isFree()) {
+            headerAddress += header->size();
+            continue;
+        }
+        header->checkHeader();
+
+        if (startOfGap != headerAddress)
+            heapForNormalPage()->addToFreeList(startOfGap, headerAddress - startOfGap);
+        if (header->isMarked()) {
+            header->unmark();
+            markedObjectSize += header->size();
+        }
+        headerAddress += header->size();
+        startOfGap = headerAddress;
+    }
+    if (startOfGap != payloadEnd())
+        heapForNormalPage()->addToFreeList(startOfGap, payloadEnd() - startOfGap);
+
+    if (markedObjectSize)
+        Heap::increaseMarkedObjectSize(markedObjectSize);
+}
+
 #if defined(ADDRESS_SANITIZER)
 void NormalPage::poisonUnmarkedObjects()
 {
     for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         ASSERT(header->size() < blinkPagePayloadSize());
         // Check if a free list entry first since we cannot call
         // isMarked on a free list entry.
         if (header->isFree()) {
             headerAddress += header->size();
@@ skipping 269 matching lines @@
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (header->isMarked()) {
         header->unmark();
         Heap::increaseMarkedObjectSize(size());
     } else {
         header->markDead();
     }
 }
 
+void LargeObjectPage::makeConsistentForMutator()
+{
+    HeapObjectHeader* header = heapObjectHeader();
+    if (header->isMarked()) {
+        header->unmark();
+        Heap::increaseMarkedObjectSize(size());
+    }
+}
+
 #if defined(ADDRESS_SANITIZER)
 void LargeObjectPage::poisonUnmarkedObjects()
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (!header->isMarked())
         ASAN_POISON_MEMORY_REGION(header->payload(), header->payloadSize());
 }
 #endif
 
 void LargeObjectPage::checkAndMarkPointer(Visitor* visitor, Address address)
@@ skipping 743 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