Allow creating non-thread-local Persistents that can be passed between threads.

Source/heap/ThreadState.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 309 matching lines @@
     if (!state->isAtSafePoint())
         state->enterSafePointWithoutPointers();
     MutexLocker locker(threadAttachMutex());
     state->leaveSafePoint();
     attachedThreads().remove(state);
     delete state;
 }
 
 void ThreadState::visitRoots(Visitor* visitor)
 {
+    {
+        // All threads are at safepoints so this is not strictly necessary.
+        // However we acquire the mutex to make mutation and traversal of this
+        // list symmetrical.
+        MutexLocker locker(globalRootsMutex());
+        globalRoots()->trace(visitor);
+    }
+
     AttachedThreadStateSet& threads = attachedThreads();
     for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->trace(visitor);
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitStack(Visitor* visitor)
 {
     Address* start = reinterpret_cast<Address*>(m_startOfStack);
     // If there is a safepoint scope marker we should stop the stack
     // scanning there to not touch active parts of the stack. Anything
     // interesting beyond that point is in the safepoint stack copy.
     // If there is no scope marker the thread is blocked and we should
     // scan all the way to the recorded end stack pointer.
     Address* end = reinterpret_cast<Address*>(m_endOfStack);
     Address* safePointScopeMarker = reinterpret_cast<Address*>(m_safePointScopeMarker);
     Address* current = safePointScopeMarker ? safePointScopeMarker : end;
 
     // Ensure that current is aligned by address size otherwise the loop below
     // will read past start address.
     current = reinterpret_cast<Address*>(reinterpret_cast<intptr_t>(current) & ~(sizeof(Address) - 1));
 
     for (; current < start; ++current)
         Heap::checkAndMarkPointer(visitor, *current);
 
     for (Vector<Address>::iterator it = m_safePointStackCopy.begin(); it != m_safePointStackCopy.end(); ++it)
         Heap::checkAndMarkPointer(visitor, *it);
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)

[haraken, 2014/02/18 01:35:12]

I sometimes find it confusing that we have visitPersistents(), visitRoots()
(which visits persistent handles), visitRoots() (which visits all GC roots),
roots(), m_persistents...

Probably we want to rename the methods based on the following rule:

- "roots" means GC roots (including persistent handles, stack etc)
- "persistents" means persistent handles.

For example, we can rename RootsAccessor to PersistentsAccessor etc.

 {
-    for (PersistentNode* current = m_persistents->m_next; current != m_persistents; current = current->m_next) {
-        current->trace(visitor);
-    }
+    m_persistents->trace(visitor);
 }
 
 void ThreadState::trace(Visitor* visitor)
 {
     if (m_stackState == HeapPointersOnStack)
         visitStack(visitor);
     visitPersistents(visitor);
 }
 
 bool ThreadState::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     // If thread is cleaning up ignore conservative pointers.
     if (m_isCleaningUp)
         return false;
 
     BaseHeapPage* page = heapPageFromAddress(address);
     if (page)
         return page->checkAndMarkPointer(visitor, address);
     // Not in heap pages, check large objects
     for (int i = 0; i < NumberOfHeaps; i++) {
         if (m_heaps[i]->checkAndMarkLargeHeapObject(visitor, address))
             return true;
     }
     return false;
 }
 
+PersistentNode* ThreadState::globalRoots()
+{
+    AtomicallyInitializedStatic(PersistentNode*, anchor = new PersistentAnchor);
+    return anchor;
+}
+
+Mutex& ThreadState::globalRootsMutex()
+{
+    AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
+    return mutex;
+}
+
 // Trigger garbage collection on a 50% increase in size, but not for
 // less than 2 pages.
 static bool increasedEnoughToGC(size_t newSize, size_t oldSize)
 {
     if (newSize < 2 * blinkPagePayloadSize())
         return false;
     return newSize > oldSize + (oldSize >> 1);
 }
 
 // FIXME: The heuristics are local for a thread at this
@@ skipping 278 matching lines @@
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }