Oilpan: Rename makeConsistentForSweeping to makeConsistentForGC

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 214 matching lines @@
             return page;
     }
     return nullptr;
 }
 #endif
 
 #if ENABLE(GC_PROFILING)
 #define GC_PROFILE_HEAP_PAGE_SNAPSHOT_THRESHOLD 0
 void BaseHeap::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
 {
-    ASSERT(isConsistentForSweeping());
+    ASSERT(isConsistentForGC());
     size_t previousPageCount = info->pageCount;
 
     json->beginArray("pages");
     for (BasePage* page = m_firstPage; page; page = page->next(), ++info->pageCount) {
         // FIXME: To limit the size of the snapshot we only output "threshold" many page snapshots.
         if (info->pageCount < GC_PROFILE_HEAP_PAGE_SNAPSHOT_THRESHOLD) {
             json->beginArray();
             json->pushInteger(reinterpret_cast<intptr_t>(page));
             page->snapshot(json, info);
             json->endArray();
@@ skipping 18 matching lines @@
         page->countObjectsToSweep(classAgeCounts);
 }
 
 void BaseHeap::incrementMarkedObjectsAge()
 {
     for (BasePage* page = m_firstPage; page; page = page->next())
         page->incrementMarkedObjectsAge();
 }
 #endif
 
-void BaseHeap::makeConsistentForSweeping()
+void BaseHeap::makeConsistentForGC()
 {
     clearFreeLists();
-    ASSERT(isConsistentForSweeping());
+    ASSERT(isConsistentForGC());
     for (BasePage* page = m_firstPage; page; page = page->next())
         page->markAsUnswept();
 
     // If a new GC is requested before this thread got around to sweep,
     // ie. due to the thread doing a long running operation, we clear
     // the mark bits and mark any of the dead objects as dead. The latter
     // is used to ensure the next GC marking does not trace already dead
     // objects. If we trace a dead object we could end up tracing into
     // garbage or the middle of another object via the newly conservatively
     // found object.
     BasePage* previousPage = nullptr;
     for (BasePage* page = m_firstUnsweptPage; page; previousPage = page, page = page->next()) {
-        page->markUnmarkedObjectsDead();
+        page->makeConsistentForGC();
         ASSERT(!page->hasBeenSwept());
     }
     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(isConsistentForSweeping());
+    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()
 {
@@ skipping 119 matching lines @@
     clearFreeLists();
 }
 
 void NormalPageHeap::clearFreeLists()
 {
     setAllocationPoint(nullptr, 0);
     m_freeList.clear();
 }
 
 #if ENABLE(ASSERT)
-bool NormalPageHeap::isConsistentForSweeping()
+bool NormalPageHeap::isConsistentForGC()
 {
     // A thread heap is consistent for sweeping if none of the pages to be swept
     // contain a freelist block or the current allocation point.
     for (size_t i = 0; i < blinkPageSizeLog2; ++i) {
         for (FreeListEntry* freeListEntry = m_freeList.m_freeLists[i]; freeListEntry; freeListEntry = freeListEntry->next()) {
             if (pagesToBeSweptContains(freeListEntry->address()))
                 return false;
         }
     }
     if (hasCurrentAllocationArea()) {
@@ skipping 692 matching lines @@
         markedObjectSize += header->size();
         startOfGap = headerAddress;
     }
     if (startOfGap != payloadEnd())
         heapForNormalPage()->addToFreeList(startOfGap, payloadEnd() - startOfGap);
 
     if (markedObjectSize)
         Heap::increaseMarkedObjectSize(markedObjectSize);
 }
 
-void NormalPage::markUnmarkedObjectsDead()
+void NormalPage::makeConsistentForGC()
 {
     size_t markedObjectSize = 0;
     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;
@@ skipping 282 matching lines @@
 {
     static_cast<LargeObjectHeap*>(heap())->freeLargeObjectPage(this);
 }
 
 void LargeObjectPage::sweep()
 {
     heapObjectHeader()->unmark();
     Heap::increaseMarkedObjectSize(size());
 }
 
-void LargeObjectPage::markUnmarkedObjectsDead()
+void LargeObjectPage::makeConsistentForGC()
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (header->isMarked()) {
         header->unmark();
         Heap::increaseMarkedObjectSize(size());
     } else {
         header->markDead();
     }
 }
 
@@ skipping 622 matching lines @@
         Platform::current()->histogramEnumeration("BlinkGC.CommittedSize", sizeInMB, supportedMaxSizeInMB);
         observedMaxSizeInMB = sizeInMB;
     }
 }
 
 size_t Heap::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
     for (ThreadState* state : ThreadState::attachedThreads()) {
         state->setGCState(ThreadState::GCRunning);
-        state->makeConsistentForSweeping();
+        state->makeConsistentForGC();
         objectPayloadSize += state->objectPayloadSizeForTesting();
         state->setGCState(ThreadState::EagerSweepScheduled);
         state->setGCState(ThreadState::Sweeping);
         state->setGCState(ThreadState::NoGCScheduled);
     }
     return objectPayloadSize;
 }
 
 BasePage* Heap::lookup(Address address)
 {
@@ skipping 109 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