[oilpan]: Make thread shutdown more robust.

Source/platform/heap/ThreadState.h

 /*
  * 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 31 matching lines @@
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 class BaseHeap;
 class BaseHeapPage;
 class FinalizedHeapObjectHeader;
 struct GCInfo;
 class HeapContainsCache;
 class HeapObjectHeader;
+class PageMemory;
 class PersistentNode;
 class Visitor;
 class SafePointBarrier;
 class SafePointAwareMutexLocker;
 template<typename Header> class ThreadHeap;
 class CallbackStack;
 
 typedef uint8_t* Address;
 
 typedef void (*FinalizationCallback)(void*);
@@ skipping 438 matching lines @@
     static const GCInfo* findGCInfoFromAllThreads(Address);
 #endif
 
     void pushWeakObjectPointerCallback(void*, WeakPointerCallback);
     bool popAndInvokeWeakPointerCallback(Visitor*);
 
     void getStats(HeapStats&);
     HeapStats& stats() { return m_stats; }
     HeapStats& statsAfterLastGC() { return m_statsAfterLastGC; }
 
+    void setupHeapsForShutdown();
+    void visitLocalRoots(Visitor*);
+
 private:
     explicit ThreadState();
     ~ThreadState();
 
     friend class SafePointBarrier;
     friend class SafePointAwareMutexLocker;
 
     void enterSafePoint(StackState, void*);
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
     void clearSafePointScopeMarker()
@@ skipping 130 matching lines @@
     {
         ASSERT(m_locked);
         m_mutex.unlock();
         m_locked = false;
     }
 
     Mutex& m_mutex;
     bool m_locked;
 };
 
+// Common header for heap pages. Needs to be defined before class Visitor.

[Mads Ager (chromium), 2014/07/08 08:24:56]

Our file setup is becoming really messy. :-\ This change is important to land,
so let's leave it this way but it seems messy to have BaseHeapPage here and all
the subclasses in Heap.h. Maybe we should split into more files, but let's leave
that for later.

[wibling-chromium, 2014/07/08 13:39:48]

Agree. I was more thinking about going in the opposite direction and combining
some of our header files, since they seems to be quite intertwined anyway.

+class BaseHeapPage {
+public:
+    BaseHeapPage(PageMemory*, const GCInfo*, ThreadState*);
+    virtual ~BaseHeapPage() { }
+
+    // Check if the given address points to an object in this
+    // heap page. If so, find the start of that object and mark it
+    // using the given Visitor. Otherwise do nothing. The pointer must
+    // be within the same aligned blinkPageSize as the this-pointer.
+    //
+    // This is used during conservative stack scanning to
+    // conservatively mark all objects that could be referenced from
+    // the stack.
+    virtual void checkAndMarkPointer(Visitor*, Address) = 0;
+    virtual bool contains(Address) = 0;
+
+#if ENABLE(GC_TRACING)
+    virtual const GCInfo* findGCInfo(Address) = 0;
+#endif
+
+    Address address() { return reinterpret_cast<Address>(this); }
+    PageMemory* storage() const { return m_storage; }
+    ThreadState* threadState() const { return m_threadState; }
+    const GCInfo* gcInfo() { return m_gcInfo; }
+    virtual bool isLargeObject() { return false; }
+    virtual void markOrphaned()
+    {
+        m_threadState = 0;
+        m_shuttingDown = false;
+        m_traced = false;
+    }
+    bool orphaned() { return !m_threadState; }
+    bool shuttingDown() { return m_shuttingDown; }
+    void setShutdown() { m_shuttingDown = true; }
+    bool traced() { return m_traced; }
+    void setTraced() { m_traced = true; }
+    bool reuseMemory() { return m_reuseMemory; }
+    void clearReuseMemory() { m_reuseMemory = false; }
+    void setReuseMemory() { m_reuseMemory = true; }

[haraken, 2014/07/08 05:44:51]

Instead of introducing clearReuseMemory and setReuseMemory, can we just override
reuseMemory() in LargeHeapObject so that reuseMemory() returns true only for
LargeHeapObjects?

[Mads Ager (chromium), 2014/07/08 08:24:56]

We already have this information. We have the virtual isLargeObject method, so I
think we should just use that one? :)

[wibling-chromium, 2014/07/08 13:39:48]

Done.

[wibling-chromium, 2014/07/08 13:39:48]

I got rid of this and used isLargeObject as suggested by Mads.

+
+private:
+    // Accessor to silence unused warnings for the m_padding field.
+    intptr_t padding() const { return m_padding; }
+
+    PageMemory* m_storage;
+    const GCInfo* m_gcInfo;
+    ThreadState* m_threadState;
+    bool m_shuttingDown;
+    bool m_traced;
+    bool m_reuseMemory;

[Mads Ager (chromium), 2014/07/08 08:24:56]

Are you sure we are maintaining correct alignment now? Unfortunately, this might
only break on Windows if we get it wrong.

[wibling-chromium, 2014/07/08 13:39:48]

No, I will spend some time to make sure it is okay.

+    // Pointer sized integer to ensure proper alignment of the
+    // HeapPage header. This can be used as a bit field if we need
+    // to associate more information with pages.
+    intptr_t m_padding;
+};
+
 }
 
 #endif // ThreadState_h