Oilpan: GC_TRACING: Improve object path dump

Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 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 269 matching lines @@
 // A Persistent is always a GC root from the point of view of
 // the garbage collector.
 //
 // We have to construct and destruct Persistent with default RootsAccessor in
 // the same thread.
 template<typename T, typename RootsAccessor /* = ThreadLocalPersistents<ThreadingTrait<T>::Affinity > */ >
 class Persistent : public PersistentBase<RootsAccessor, Persistent<T, RootsAccessor> > {
     WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(Persistent);
     WTF_DISALLOW_ZERO_ASSIGNMENT(Persistent);
 public:
-    Persistent() : m_raw(0) { }
+    Persistent() : m_raw(0) { recordBacktrace(); }

[haraken, 2014/06/16 01:15:40]

I'm not sure if you want to record a backtrace for a null persistent.

 
-    Persistent(std::nullptr_t) : m_raw(0) { }
+    Persistent(std::nullptr_t) : m_raw(0) { recordBacktrace(); }

[haraken, 2014/06/16 01:15:40]

Ditto.

 
     Persistent(T* raw) : m_raw(raw)
     {
         ASSERT_IS_VALID_PERSISTENT_POINTER(m_raw);
+        recordBacktrace();
     }
 
     explicit Persistent(T& raw) : m_raw(&raw)
     {
         ASSERT_IS_VALID_PERSISTENT_POINTER(m_raw);
+        recordBacktrace();
     }
 
-    Persistent(const Persistent& other) : m_raw(other) { }
+    Persistent(const Persistent& other) : m_raw(other) { recordBacktrace(); }
 
     template<typename U>
-    Persistent(const Persistent<U, RootsAccessor>& other) : m_raw(other) { }
+    Persistent(const Persistent<U, RootsAccessor>& other) : m_raw(other) { recordBacktrace(); }
 
     template<typename U>
-    Persistent(const Member<U>& other) : m_raw(other) { }
+    Persistent(const Member<U>& other) : m_raw(other) { recordBacktrace(); }
 
     template<typename U>
-    Persistent(const RawPtr<U>& other) : m_raw(other.get()) { }
+    Persistent(const RawPtr<U>& other) : m_raw(other.get()) { recordBacktrace(); }
 
     template<typename U>
     Persistent& operator=(U* other)
     {
         m_raw = other;

[haraken, 2014/06/16 01:15:40]

You'll need recordBacktrace() here as well.

         return *this;
     }
 
     Persistent& operator=(std::nullptr_t)
     {
         m_raw = 0;
         return *this;
     }
 
     void clear() { m_raw = 0; }
 
     virtual ~Persistent()
     {
         m_raw = 0;
     }
 
     template<typename U>
     U* as() const
     {
         return static_cast<U*>(m_raw);
     }
 
     void trace(Visitor* visitor)
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInPersistent);
 #if ENABLE(GC_TRACING)
-        visitor->setHostInfo(this, "Persistent");
+        visitor->setHostInfo(this, m_tracingName.isEmpty() ? "Persistent" : m_tracingName);

[haraken, 2014/06/16 01:15:40]

Just help me understand: In what situation can the m_tracingName be empty?

[tkent, 2014/06/16 02:34:47]

When we forget to add recordBacktrace() :-)

 #endif
         visitor->mark(m_raw);
     }
 
     T* release()
     {
         T* result = m_raw;
         m_raw = 0;
         return result;
     }
 
     T& operator*() const { return *m_raw; }
 
     bool operator!() const { return !m_raw; }
 
     operator T*() const { return m_raw; }
     operator RawPtr<T>() const { return m_raw; }
 
     T* operator->() const { return *this; }
 
     Persistent& operator=(const Persistent& other)
     {
         m_raw = other;

[haraken, 2014/06/16 01:15:40]

You'll need recordBacktrace() here.

         return *this;
     }
 
     template<typename U>
     Persistent& operator=(const Persistent<U, RootsAccessor>& other)
     {
         m_raw = other;

[haraken, 2014/06/16 01:15:40]

You'll need recordBacktrace() here.

         return *this;
     }
 
     template<typename U>
     Persistent& operator=(const Member<U>& other)
     {
         m_raw = other;

[haraken, 2014/06/16 01:15:40]

You'll need recordBacktrace() here.

         return *this;
     }
 
     template<typename U>
     Persistent& operator=(const RawPtr<U>& other)
     {
         m_raw = other;

[haraken, 2014/06/16 01:15:40]

You'll need recordBacktrace() here.

My proposal is:

- Implement a private helper method to set m_raw (e.g. Persistent::setRaw()),
and call recordBacktrace() in the helper method.
- Call recordBacktrace() only when m_raw is not 0.

[tkent, 2014/06/16 02:34:47]

I thought adding recordBacktrace() to constructors was enough. In this policy we
needed to add recordBacktrace()  even if m_raw is 0 and we didn't need to add
recordBacktrace to operator=.
Your policy, adding recordBacktrace to any code to update m_raw, is also
reasonable.  I changed so in Patch Set 3.

I don't apply the seRaw() helper idea because I'd like to initialize m_raw in
initializer lists as possible.

         return *this;
     }
 
     T* get() const { return m_raw; }
 
 private:
+#if ENABLE(GC_TRACING)
+    void recordBacktrace()
+    {
+        m_tracingName = Heap::createBacktraceString();
+    }
+
+    String m_tracingName;
+#else
+    inline void recordBacktrace() { }
+#endif
     T* m_raw;
 
     friend class CrossThreadPersistent<T>;
 };
 
 // Unlike Persistent, we can destruct a CrossThreadPersistent in a thread
 // different from the construction thread.
 template<typename T>
 class CrossThreadPersistent : public Persistent<T, GlobalPersistents> {
     WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(CrossThreadPersistent);
@@ skipping 12 matching lines @@
     // We overload the various new and delete operators with using the WTF DefaultAllocator to ensure persistent
     // heap collections are always allocated off-heap. This allows persistent collections to be used in
     // DEFINE_STATIC_LOCAL et. al.
     WTF_USE_ALLOCATOR(PersistentHeapCollectionBase, WTF::DefaultAllocator);
 public:
     PersistentHeapCollectionBase() { }
 
     template<typename OtherCollection>
     PersistentHeapCollectionBase(const OtherCollection& other) : Collection(other) { }
 
-    void trace(Visitor* visitor) { visitor->trace(*static_cast<Collection*>(this)); }
+    void trace(Visitor* visitor)
+    {
+#if ENABLE(GC_TRACING)
+        visitor->setHostInfo(this, "PersistentHeapCollectionBase");
+#endif
+        visitor->trace(*static_cast<Collection*>(this));
+    }
 };
 
 template<
     typename KeyArg,
     typename MappedArg,
     typename HashArg = typename DefaultHash<KeyArg>::Hash,
     typename KeyTraitsArg = HashTraits<KeyArg>,
     typename MappedTraitsArg = HashTraits<MappedArg> >
 class PersistentHeapHashMap : public PersistentHeapCollectionBase<HeapHashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> > { };
 
@@ skipping 737 matching lines @@
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 template<typename T>
 struct ParamStorageTraits<RawPtr<T> > : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 } // namespace WTF
 
 #endif