[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 170 matching lines @@
     // The set of ThreadStates for all threads attached to the Blink
     // garbage collector.
     typedef HashSet<ThreadState*> AttachedThreadStateSet;
     static AttachedThreadStateSet& attachedThreads();
 
     // Initialize threading infrastructure. Should be called from the main
     // thread.
     static void init();
     static void shutdown();
     static void shutdownHeapIfNecessary();
+    bool isCleaningUp() { return m_isCleaningUp; }

[haraken, 2014/07/09 05:17:49]

isCleaningUp => isTerminating ?

We don't want to mix "clean up", "shut down" and "terminate".

[wibling-chromium, 2014/07/09 10:32:31]

Done.

 
     static void attachMainThread();
     static void detachMainThread();
 
     // Trace all GC roots, called when marking the managed heap objects.
     static void visitRoots(Visitor*);
 
     // Associate ThreadState object with the current thread. After this
     // call thread can start using the garbage collected heap infrastructure.
     // It also has to periodically check for safepoints.
@@ skipping 248 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 85 matching lines @@
 };
 
 // The SafePointAwareMutexLocker is used to enter a safepoint while waiting for
 // a mutex lock. It also ensures that the lock is not held while waiting for a GC
 // to complete in the leaveSafePoint method, by releasing the lock if the
 // leaveSafePoint method cannot complete without blocking, see
 // SafePointBarrier::checkAndPark.
 class SafePointAwareMutexLocker {
     WTF_MAKE_NONCOPYABLE(SafePointAwareMutexLocker);
 public:
-    explicit SafePointAwareMutexLocker(Mutex& mutex) : m_mutex(mutex), m_locked(false)
+    explicit SafePointAwareMutexLocker(Mutex& mutex, ThreadState::StackState stackState = ThreadState::HeapPointersOnStack)
+        : m_mutex(mutex)
+        , m_locked(false)
     {
         ThreadState* state = ThreadState::current();
         do {
             bool leaveSafePoint = false;
             // We cannot enter a safepoint if we are currently sweeping. In that
             // case we just try to acquire the lock without being at a safepoint.
             // If another thread tries to do a GC at that time it might time out
             // due to this thread not being at a safepoint and waiting on the lock.
             if (!state->isSweepInProgress() && !state->isAtSafePoint()) {
-                state->enterSafePoint(ThreadState::HeapPointersOnStack, this);
+                state->enterSafePoint(stackState, this);
                 leaveSafePoint = true;
             }
             m_mutex.lock();
             m_locked = true;
             if (leaveSafePoint) {
                 // When leaving the safepoint we might end up release the mutex
                 // if another thread is requesting a GC, see
                 // SafePointBarrier::checkAndPark. This is the case where we
                 // loop around to reacquire the lock.
                 state->leaveSafePoint(this);
@@ skipping 14 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.
+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;

[haraken, 2014/07/09 05:17:48]

Shall we also clear m_gcInfo here?

It looks a bit inconsistent that GCInfos on object headers are already cleared
but GCInfos on page headers still remain.

[wibling-chromium, 2014/07/09 10:32:31]

Sure, I don't have a strong feeling either way. That does require us to also add
the orphaned page check to the other checkGCInfo.

+    }
+    bool orphaned() { return !m_threadState; }
+    bool shuttingDown() { return m_shuttingDown; }
+    void setShutdown() { m_shuttingDown = true; }

[haraken, 2014/07/09 05:17:48]

m_shuttingDown => m_terminating ?

[wibling-chromium, 2014/07/09 10:32:31]

Done.

+    bool traced() { return m_traced; }
+    void setTraced() { m_traced = true; }

[haraken, 2014/07/09 05:17:48]

m_traced => m_tracedAfterShutdown or m_tracedAfterOrphaned ?

[wibling-chromium, 2014/07/09 10:32:31]

Done. Changed it to m_tracedAfterOrphaned.

+
+private:
+    PageMemory* m_storage;
+    const GCInfo* m_gcInfo;
+    ThreadState* m_threadState;
+    // Pointer sized integer to ensure proper alignment of the
+    // HeapPage header. We use some of the bits to determine
+    // whether the page is part of a shutting down thread or
+    // if the page is traced after being shut down (orphaned).
+    uintptr_t m_shuttingDown : 1;
+    uintptr_t m_traced : 1;
+};
+
 }
 
 #endif // ThreadState_h