Oilpan: Implement bitmap marking

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 438 matching lines @@
             ThreadState::resumeThreads();
         }
     }
 
 private:
     ThreadState* m_state;
     ThreadState::SafePointScope m_safePointScope;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
-NO_SANITIZE_ADDRESS inline
-bool HeapObjectHeader::isMarked() const
+inline bool HeapObjectHeader::isMarked() const
 {
     checkHeader();
-    return m_size & markBitMask;
+    return pageHeaderFromObject(this)->objectIsMarked(reinterpret_cast<Address>(const_cast<HeapObjectHeader*>(this)));
 }
 
 NO_SANITIZE_ADDRESS inline
-void HeapObjectHeader::unmark()
-{
-    checkHeader();
-    m_size &= ~markBitMask;
-}
-
-NO_SANITIZE_ADDRESS inline
 bool HeapObjectHeader::hasDeadMark() const
 {
     checkHeader();
     return m_size & deadBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::clearDeadMark()
 {
     checkHeader();
@@ skipping 48 matching lines @@
     // This happens right after sweeping the page and before the thread commences execution.
 }
 
 NO_SANITIZE_ADDRESS
 void FinalizedHeapObjectHeader::finalize()
 {
     HeapObjectHeader::finalize(m_gcInfo, payload(), payloadSize());
 }
 
 template<typename Header>
-void LargeHeapObject<Header>::unmark()
-{
-    return heapObjectHeader()->unmark();
-}
-
-template<typename Header>
 bool LargeHeapObject<Header>::isMarked()
 {
     return heapObjectHeader()->isMarked();
 }
 
 template<typename Header>
 void LargeHeapObject<Header>::setDeadMark()
 {
     heapObjectHeader()->setDeadMark();
 }
@@ skipping 607 matching lines @@
             PageMemory* memory = page->storage();
             ASSERT(memory);
             page->~BaseHeapPage();
             delete memory;
         }
     }
 }
 
 void OrphanedPagePool::addOrphanedPage(int index, BaseHeapPage* page)
 {
+    page->clearObjectMarkBitMap();
     page->markOrphaned();
     PoolEntry* entry = new PoolEntry(page, m_pool[index]);
     m_pool[index] = entry;
 }
 
 NO_SANITIZE_ADDRESS
 void OrphanedPagePool::decommitOrphanedPages()
 {
 #if ENABLE(ASSERT)
     // No locking needed as all threads are at safepoints at this point in time.
@@ skipping 222 matching lines @@
 }
 
 template<typename Header>
 void ThreadHeap<Header>::sweepLargePages()
 {
     TRACE_EVENT0("blink_gc", "ThreadHeap::sweepLargePages");
     LargeHeapObject<Header>** previousNext = &m_firstLargeHeapObject;
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current;) {
         if (current->isMarked()) {
             Heap::increaseMarkedObjectSize(current->size());
-            current->unmark();
             previousNext = &current->m_next;
             current = current->next();
         } else {
             LargeHeapObject<Header>* next = current->next();
             freeLargeObject(current, previousNext);
             current = next;
         }
     }
 }
 
@@ skipping 61 matching lines @@
 template<typename Header>
 void ThreadHeap<Header>::makeConsistentForSweeping()
 {
     if (ownsNonEmptyAllocationArea())
         addToFreeList(currentAllocationPoint(), remainingAllocationSize());
     setAllocationPoint(0, 0);
     clearFreeLists();
 }
 
 template<typename Header>
-void ThreadHeap<Header>::clearLiveAndMarkDead()
+void ThreadHeap<Header>::makeUnmarkedObjectsDead()
 {
     ASSERT(isConsistentForSweeping());
-    for (HeapPage<Header>* page = m_firstPage; page; page = page->next())
-        page->clearLiveAndMarkDead();
+    for (HeapPage<Header>* page = m_firstPage; page; page = page->next()) {
+        page->makeUnmarkedObjectsDead();
+    }
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
-        if (current->isMarked())
-            current->unmark();
-        else
+        if (!current->isMarked())
             current->setDeadMark();
     }
 }
 
 template<typename Header>
+void ThreadHeap<Header>::clearObjectMarkBitMaps()
+{
+    ASSERT(isConsistentForSweeping());
+    for (HeapPage<Header>* page = m_firstPage; page; page = page->next()) {
+        page->clearObjectMarkBitMap();
+    }
+    for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
+        current->clearObjectMarkBitMap();
+    }
+}
+
+template<typename Header>
 void ThreadHeap<Header>::clearFreeLists()
 {
     m_promptlyFreedCount = 0;
     m_freeList.clear();
 }
 
 template<typename Header>
 void FreeList<Header>::clear()
 {
     m_biggestFreeListIndex = 0;
@@ skipping 19 matching lines @@
 HeapPage<Header>::HeapPage(PageMemory* storage, ThreadHeap<Header>* heap, const GCInfo* gcInfo)
     : BaseHeapPage(storage, gcInfo, heap->threadState())
     , m_next(0)
 {
     COMPILE_ASSERT(!(sizeof(HeapPage<Header>) & allocationMask), page_header_incorrectly_aligned);
     m_objectStartBitMapComputed = false;
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
 template<typename Header>
+void HeapPage<Header>::clearObjectMarkBitMap()
+{
+    memset(&m_objectMarkBitMap, 0, reservedForObjectMarkBitMap);
+}
+
+template<typename Header>
 void HeapPage<Header>::link(HeapPage** prevNext)
 {
     m_next = *prevNext;
     *prevNext = this;
 }
 
 template<typename Header>
 void HeapPage<Header>::unlink(ThreadHeap<Header>* heap, HeapPage* unused, HeapPage** prevNext)
 {
     *prevNext = unused->m_next;
@@ skipping 65 matching lines @@
             // that memory on the freelist is zero filled.
             memset(headerAddress, 0, size);
 #endif
             ASAN_POISON_MEMORY_REGION(header->payload(), header->payloadSize());
             headerAddress += size;
             continue;
         }
 
         if (startOfGap != headerAddress)
             heap->addToFreeList(startOfGap, headerAddress - startOfGap);
-        header->unmark();
         headerAddress += header->size();
         Heap::increaseMarkedObjectSize(header->size());
         startOfGap = headerAddress;
     }
     if (startOfGap != end())
         heap->addToFreeList(startOfGap, end() - startOfGap);
 }
 
 template<typename Header>
-void HeapPage<Header>::clearLiveAndMarkDead()
+void HeapPage<Header>::makeUnmarkedObjectsDead()
 {
     for (Address headerAddress = payload(); headerAddress < end();) {
         Header* header = reinterpret_cast<Header*>(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;
         }
-        if (header->isMarked())
-            header->unmark();
-        else
+        if (!header->isMarked())
             header->setDeadMark();
         headerAddress += header->size();
     }
 }
 
 template<typename Header>
 void HeapPage<Header>::populateObjectStartBitMap()
 {
     memset(&m_objectStartBitMap, 0, objectStartBitMapSize);
     Address start = payload();
@@ skipping 1173 matching lines @@
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = 0;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink