Do not fire timers for finalizing objects.

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 525 matching lines @@
 {
     HeapObjectHeader* header = heapObjectHeader();
     if (header->isMarked())
         header->unmark();
     else
         header->markDead();
 }
 
 void LargeObject::removeFromHeap(ThreadHeap* heap)
 {
+    m_sweepStatus = 0;
     heap->freeLargeObject(this);
 }
 
 ThreadHeap::ThreadHeap(ThreadState* state, int index)
     : m_currentAllocationPoint(nullptr)
     , m_remainingAllocationSize(0)
     , m_lastRemainingAllocationSize(0)
     , m_firstPage(nullptr)
     , m_firstLargeObject(nullptr)
     , m_firstUnsweptPage(nullptr)
@@ skipping 184 matching lines @@
         HeapPage* page = m_firstUnsweptPage;
         if (page->isEmpty()) {
             page->unlink(&m_firstUnsweptPage);
             page->removeFromHeap(this);
         } else {
             // Sweep a page and move the page from m_firstUnsweptPages to
             // m_firstPages.
             page->sweep();
             page->unlink(&m_firstUnsweptPage);
             page->link(&m_firstPage);
+            page->markAsLazilySwept();
 
             result = allocateFromFreeList(allocationSize, gcInfoIndex);
-            if (result) {
+            if (result)
                 break;
-            }
         }
     }
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
     return result;
 }
 
 bool ThreadHeap::lazySweepLargeObjects(size_t allocationSize)
 {
@@ skipping 32 matching lines @@
             if (sweptSize >= allocationSize) {
                 result = true;
                 break;
             }
         } else {
             // Sweep a large object and move the large object from
             // m_firstUnsweptLargeObjects to m_firstLargeObjects.
             largeObject->sweep();
             largeObject->unlink(&m_firstUnsweptLargeObject);
             largeObject->link(&m_firstLargeObject);
+            largeObject->markAsLazilySwept();
         }
     }
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
     return result;
 }
 
 void ThreadHeap::completeSweep()
 {
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
     ASSERT(threadState()->sweepForbidden());
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::enter();
 
     // Sweep normal pages.
     while (m_firstUnsweptPage) {
         HeapPage* page = m_firstUnsweptPage;
         if (page->isEmpty()) {
             page->unlink(&m_firstUnsweptPage);
             page->removeFromHeap(this);
         } else {
             // Sweep a page and move the page from m_firstUnsweptPages to
             // m_firstPages.
             page->sweep();
             page->unlink(&m_firstUnsweptPage);
             page->link(&m_firstPage);
+            page->markAsLazilySwept();
         }
     }
 
     // Sweep large objects.
     while (m_firstUnsweptLargeObject) {
         LargeObject* largeObject = m_firstUnsweptLargeObject;
         if (largeObject->isEmpty()) {
             largeObject->unlink(&m_firstUnsweptLargeObject);
             largeObject->removeFromHeap(this);
         } else {
             // Sweep a large object and move the large object from
             // m_firstUnsweptLargeObjects to m_firstLargeObjects.
             largeObject->sweep();
             largeObject->unlink(&m_firstUnsweptLargeObject);
             largeObject->link(&m_firstLargeObject);
+            largeObject->markAsLazilySwept();
         }
     }
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
 }
 
 #if ENABLE(ASSERT)
 static bool isLargeObjectAligned(LargeObject* largeObject, Address address)
 {
@@ skipping 371 matching lines @@
 }
 
 BaseHeapPage::BaseHeapPage(PageMemory* storage, ThreadHeap* heap)
     : m_storage(storage)
     , m_heap(heap)
     , m_terminating(false)
 {
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
+void BaseHeapPage::markAsLazilySwept()
+{
+    // To signal completion of a lazy sweep, update the
+    // page's sweep status to match that of the ThreadState's
+    // flip-flop sweep token.
+    bool currentToken = heap()->threadState()->lazySweepToken();
+    m_sweepStatus = currentToken ? 2 : 1;
+}
+
+bool BaseHeapPage::hasBeenLazilySwept() const
+{
+    // Returns true if this page has been swept
+    // by the ongoing lazy sweep operation.
+    ASSERT(heap()->threadState()->isSweepingInProgress());
+    ASSERT(m_sweepStatus <= 2);
+
+    // Page has been swept, freed.
+    if (!m_sweepStatus)
+        return false;
+
+    bool currentToken = heap()->threadState()->lazySweepToken();
+    return currentToken == (m_sweepStatus == 2);

[haraken, 2015/01/16 13:40:01]

The token looks a bit tricky to me. Can we just define BaseHeapPage::m_unswept
and set the flag to true in prepareForSweeping()? (We'll need to scan the list
of pages in prepareForSweeping(), but the overhead would be ignorable.) The
invariant is that BaseHeapPage::m_unswept is true if and only if the
BaseHeapPage is in a linked list of m_unsweptPages or m_unsweptLargeObjects.

[sof, 2015/01/16 13:43:10]

I elected not to scan all pages (previously swept and unswept) and update this
field. That's why I did it this way.

[haraken, 2015/01/16 13:54:55]

If you need to go with the flip bit, I guess you'll also need to re-flip the bit
in markUnmarkedObjectsDead(). (That said, it seems a bit complicated, so if it
doesn't matter for performance, I'd prefer just scanning all pages in
prepareForSweep.)

+}
+
 void BaseHeapPage::markOrphaned()
 {
     m_heap = nullptr;
     m_terminating = false;
     // Since we zap the page payload for orphaned pages we need to mark it as
     // unused so a conservative pointer won't interpret the object headers.
     storage()->markUnused();
 }
 
 OrphanedPagePool::~OrphanedPagePool()
@@ skipping 360 matching lines @@
         if (header->isMarked())
             header->unmark();
         else
             header->markDead();
         headerAddress += header->size();
     }
 }
 
 void HeapPage::removeFromHeap(ThreadHeap* heap)
 {
+    m_sweepStatus = 0;
     heap->freePage(this);
 }
 
 void HeapPage::populateObjectStartBitMap()
 {
     memset(&m_objectStartBitMap, 0, objectStartBitMapSize);
     Address start = payload();
     for (Address headerAddress = start; headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         size_t objectOffset = headerAddress - start;
@@ skipping 1063 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 = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink