Simple BlinkGC heap compaction.

third_party/WebKit/Source/platform/heap/HeapTest.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 314 matching lines @@
   void mark(const void* object, TraceCallback) override {
     if (object)
       m_count++;
   }
 
   void markHeader(HeapObjectHeader* header, TraceCallback callback) override {
     ASSERT(header->payload());
     m_count++;
   }
 
-  void registerDelayedMarkNoTracing(const void*) override {}
+  void registerDelayedMarkNoTracing(void**) override {}
   void registerWeakMembers(const void*, const void*, WeakCallback) override {}
   void registerWeakTable(const void*,
                          EphemeronCallback,
                          EphemeronCallback) override {}
 #if ENABLE(ASSERT)
   bool weakTableRegistered(const void*) override { return false; }
 #endif
   void registerWeakCellWithCallback(void**, WeakCallback) override {}
   bool ensureMarked(const void* objectPointer) override {
     if (!objectPointer ||
         HeapObjectHeader::fromPayload(objectPointer)->isMarked())
       return false;
     markNoTracing(objectPointer);
     return true;
   }
 
+  void registerMovingObjectReference(MovableReference*) override {}
+
+  void registerMovingObjectCallback(MovableReference,
+                                    MovingObjectCallback,
+                                    void*) override {}
+
   size_t count() { return m_count; }
   void reset() { m_count = 0; }
 
  private:
   StackFrameDepthScope m_scope;
   size_t m_count;
 };
 
 #undef DEFINE_VISITOR_METHODS
 
@@ skipping 3396 matching lines @@
     RefCountedAndGarbageCollected* pointer1 = 0;
     RefCountedAndGarbageCollected2* pointer2 = 0;
     {
       Persistent<RefCountedAndGarbageCollected> object1 =
           RefCountedAndGarbageCollected::create();
       Persistent<RefCountedAndGarbageCollected2> object2 =
           RefCountedAndGarbageCollected2::create();
       pointer1 = object1.get();
       pointer2 = object2.get();
       void* objects[2] = {object1.get(), object2.get()};
+      ThreadState::GCForbiddenScope gcScope(ThreadState::current());

[haraken, 2016/12/09 07:25:56]

Would you help me understand why these GCForbiddenScopes are needed?

[sof, 2016/12/09 21:44:04]

As long as there's a DCHECK() in the Visitor constructor that GC is forbidden
during its lifetime, they by definition are needed here.

[haraken, 2016/12/12 01:25:10]

Makes sense. I'm wondering if we can/should unify GCForbiddenScope and
SweepForbiddenScope somehow. It's getting unclearer when we should use which one
or both.

       RefCountedGarbageCollectedVisitor visitor(ThreadState::current(), 2,
                                                 objects);
       ThreadState::current()->visitPersistents(&visitor);
       EXPECT_TRUE(visitor.validate());
     }
     conservativelyCollectGarbage();
     EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
     EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
     conservativelyCollectGarbage();
     EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
     EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
     {
       // At this point, the reference counts of object1 and object2 are 0.
       // Only pointer1 and pointer2 keep references to object1 and object2.
       void* objects[] = {0};
+      ThreadState::GCForbiddenScope gcScope(ThreadState::current());
       RefCountedGarbageCollectedVisitor visitor(ThreadState::current(), 0,
                                                 objects);
       ThreadState::current()->visitPersistents(&visitor);
       EXPECT_TRUE(visitor.validate());
     }
 
     {
       Persistent<RefCountedAndGarbageCollected> object1(pointer1);
       Persistent<RefCountedAndGarbageCollected2> object2(pointer2);
       void* objects[2] = {object1.get(), object2.get()};
+      ThreadState::GCForbiddenScope gcScope(ThreadState::current());
       RefCountedGarbageCollectedVisitor visitor(ThreadState::current(), 2,
                                                 objects);
       ThreadState::current()->visitPersistents(&visitor);
       EXPECT_TRUE(visitor.validate());
     }
     conservativelyCollectGarbage();
     EXPECT_EQ(0, RefCountedAndGarbageCollected::s_destructorCalls);
     EXPECT_EQ(0, RefCountedAndGarbageCollected2::s_destructorCalls);
 
     conservativelyCollectGarbage();
@@ skipping 143 matching lines @@
 
   // This is a low-level test where we call checkAndMarkPointer. This method
   // causes the object start bitmap to be computed which requires the heap
   // to be in a consistent state (e.g. the free allocation area must be put
   // into a free list header). However when we call makeConsistentForGC it
   // also clears out the freelists so we have to rebuild those before trying
   // to allocate anything again. We do this by forcing a GC after doing the
   // checkAndMarkPointer tests.
   {
     TestGCScope scope(BlinkGC::HeapPointersOnStack);
+    ThreadState::GCForbiddenScope gcScope(ThreadState::current());
     CountingVisitor visitor(ThreadState::current());
     EXPECT_TRUE(scope.allThreadsParked());  // Fail the test if we could not
                                             // park all threads.
     heap.flushHeapDoesNotContainCache();
     for (size_t i = 0; i < objectAddresses.size(); i++) {
       EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, objectAddresses[i]));
       EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, endAddresses[i]));
     }
     EXPECT_EQ(objectAddresses.size() * 2, visitor.count());
     visitor.reset();
     EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, largeObjectAddress));
     EXPECT_TRUE(heap.checkAndMarkPointer(&visitor, largeObjectEndAddress));
     EXPECT_EQ(2ul, visitor.count());
     visitor.reset();
   }
   // This forces a GC without stack scanning which results in the objects
   // being collected. This will also rebuild the above mentioned freelists,
   // however we don't rely on that below since we don't have any allocations.
   clearOutOldGarbage();
   {
     TestGCScope scope(BlinkGC::HeapPointersOnStack);
+    ThreadState::GCForbiddenScope gcScope(ThreadState::current());
     CountingVisitor visitor(ThreadState::current());
     EXPECT_TRUE(scope.allThreadsParked());
     heap.flushHeapDoesNotContainCache();
     for (size_t i = 0; i < objectAddresses.size(); i++) {
       // We would like to assert that checkAndMarkPointer returned false
       // here because the pointers no longer point into a valid object
       // (it's been freed by the GCs. But checkAndMarkPointer will return
       // true for any pointer that points into a heap page, regardless of
       // whether it points at a valid object (this ensures the
       // correctness of the page-based on-heap address caches), so we
@@ skipping 1878 matching lines @@
 
  public:
   PartObject() : m_obj(SimpleObject::create()) {}
   DEFINE_INLINE_TRACE() { visitor->trace(m_obj); }
 
  private:
   Member<SimpleObject> m_obj;
 };
 
 TEST(HeapTest, TraceIfNeeded) {
+  ThreadState::GCForbiddenScope scope(ThreadState::current());
   CountingVisitor visitor(ThreadState::current());
 
   {
     TraceIfNeededTester<RefPtr<OffHeapInt>>* m_offHeap =
         TraceIfNeededTester<RefPtr<OffHeapInt>>::create(OffHeapInt::create(42));
     visitor.reset();
     m_offHeap->trace(&visitor);
     EXPECT_EQ(0u, visitor.count());
   }
 
@@ skipping 920 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink