Oilpan: Reduce sizeof(Persistent) to 16 byte

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 588 matching lines @@
     }
 
 protected:
     class Local final : public GarbageCollected<Local> {
     public:
         Local() { }
 
         DEFINE_INLINE_TRACE() { }
     };
 
-    class BookEnd;
+    class PersistentChain;
 
-    class PersistentStore {
+    class RefCountedChain : public RefCounted<RefCountedChain> {
     public:
-        static PersistentStore* create(int count, int* gcCount, BookEnd* bookend)
+        static RefCountedChain* create(int count)
         {
-            return new PersistentStore(count, gcCount, bookend);
-        }
-
-        void advance()
-        {
-            (*m_gcCount)++;
-            m_store.removeLast();
-            // Remove reference to BookEnd when there are no Persistent<Local>s left.
-            // The BookEnd object will then be swept out at the next GC, and pre-finalized,
-            // causing this PersistentStore instance to be destructed, along with
-            // the Persistent<BookEnd>. It being the very last Persistent<>, causing the
-            // GC loop in ThreadState::detach() to terminate.
-            if (!m_store.size())
-                m_bookend = nullptr;
+            return new RefCountedChain(count);
         }
 
     private:
-        PersistentStore(int count, int* gcCount, BookEnd* bookend)
+        explicit RefCountedChain(int count)
         {
-            m_gcCount = gcCount;
-            m_bookend = bookend;
-            for (int i = 0; i < count; ++i)
-                m_store.append(Persistent<ThreadPersistentHeapTester::Local>(new ThreadPersistentHeapTester::Local()));
+            if (count > 0) {
+                --count;
+                m_persistentChain = PersistentChain::create(count);
+            }
         }
 
-        Vector<Persistent<Local>> m_store;
-        Persistent<BookEnd> m_bookend;
-        int* m_gcCount;
+        Persistent<PersistentChain> m_persistentChain;
     };
 
-    class BookEnd final : public GarbageCollected<BookEnd> {
-        USING_PRE_FINALIZER(BookEnd, dispose);
+    class PersistentChain : public GarbageCollectedFinalized<PersistentChain> {
     public:
-        BookEnd()
-            : m_store(nullptr)
+        static PersistentChain* create(int count)
         {
-            ThreadState::current()->registerPreFinalizer(this);
+            return new PersistentChain(count);
         }
 
-        void initialize(PersistentStore* store)
+        DEFINE_INLINE_TRACE() { }
+
+    private:
+        explicit PersistentChain(int count)
         {
-            m_store = store;
+            m_refCountedChain = adoptRef(RefCountedChain::create(count));
         }
 
-        void dispose()
-        {
-            delete m_store;
-        }
-
-        DEFINE_INLINE_TRACE()

[haraken, 2015/07/01 07:43:43]

It is invalid to modify the list of persistents in trace methods. Rewrote this
test to avoid that. (This was the cause of the bot crashes.)

-        {
-            ASSERT(m_store);
-            m_store->advance();
-        }
-
-    private:
-        PersistentStore* m_store;
+        RefPtr<RefCountedChain> m_refCountedChain;
     };
 
     virtual void runThread() override
     {
         ThreadState::attach();
 
-        const int iterations = 5;
-        int gcCount = 0;
-        BookEnd* bookend = new BookEnd();
-        PersistentStore* store = PersistentStore::create(iterations, &gcCount, bookend);
-        bookend->initialize(store);
-
-        bookend = nullptr;
-        store = nullptr;
+        PersistentChain::create(100);
 
         // Upon thread detach, GCs will run until all persistents have been
         // released. We verify that the draining of persistents proceeds
         // as expected by dropping one Persistent<> per GC until there
         // are none left.
         ThreadState::detach();
-        EXPECT_EQ(iterations, gcCount);
         atomicDecrement(&m_threadsToFinish);
     }
 };
 
 // The accounting for memory includes the memory used by rounding up object
 // sizes. This is done in a different way on 32 bit and 64 bit, so we have to
 // have some slack in the tests.
 template<typename T>
 void CheckWithSlack(T expected, T actual, int slack)
 {
@@ skipping 5560 matching lines @@
 {
     Persistent<ClassWithMember> object = ClassWithMember::create();
     EXPECT_EQ(0, object->traceCount());
     TestMixinAllocatingObject* mixin = TestMixinAllocatingObject::create(object.get());
     EXPECT_TRUE(mixin);
     EXPECT_GT(object->traceCount(), 0);
     EXPECT_GT(mixin->traceCount(), 0);
 }
 
 } // namespace blink