[oilpan]: Make thread shutdown more robust.

Source/platform/heap/Visitor.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 576 matching lines @@
         visitor->checkGCInfo(const_cast<T*>(t), GCInfoTrait<T>::get());
     }
 #endif
 };
 
 template<typename T>
 class DefaultTraceTrait<T, true> {
 public:
     static void mark(Visitor* visitor, const T* self)
     {
-        if (self)
-            self->adjustAndMark(visitor);
+        if (!self)
+            return;
+
+        // Before doing adjustAndMark we need to check if the page is orphaned
+        // since we cannot call adjustAndMark if so, as there will be no vtable.
+        // If orphaned just mark the page as traced.
+        BaseHeapPage* heapPage = pageHeaderFromObject(self);
+        if (heapPage->orphaned()) {

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

Just to confirm: Is this the only place where we have to insert the
heapPage->orphaned() check before dispatching mark/trace/adjustAndMark? For
example, don't we need to insert the check into Visitor::mark() as well?

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

AFAICT we can get away with just checking here for the marking code.

We ideally don't want to put the check into the code where we are
marking/pushing the trace methods onto the marking stack. The only reason we add
it here is because we are calling a method on memory that is orphaned and hence
zapped.
Instead we are checking whether we hit an orphaned page when we pop the trace
callback off the marking stack since this means we only have to check once for
each object and it is done locally.

[haraken, 2014/07/13 17:30:38]

Just to help me understand, imagine the following object graph:

  root object => object X on an orphaned page A => object Y on a not-orphaned
page => object Z on an orphaned page B

Do we want to continue tracing from the object X to the object Y? Or do we want
to stop the tracing when we reach the object X? (In other words, do we want to
set an tracedAfterOrphaned flag on the page B or not?)

[wibling-chromium, 2014/07/14 08:06:11]

We don't want to continue tracing from X to Y. If Y is not reachable from other
objects than X then there is no need to set the traced bit on Z (ie. page B)
since it cannot be reached.
Even in the case where Y is not swept and we do a follow-up conservative GC the
dead bit should be set on Y meaning we won't continue tracing its pointers to Z.
This guarantees that we are not trying to trace through to a, now, decommited
page.

+            heapPage->setTraced();
+            return;
+        }
+        self->adjustAndMark(visitor);
     }
 
 #ifndef NDEBUG
     static void checkGCInfo(Visitor*, const T*) { }
 #endif
 };
 
 template<typename T, bool = NeedsAdjustAndMark<T>::value> class DefaultObjectAliveTrait;
 
 template<typename T>
@@ skipping 111 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif