Add more oilpan collections support

Source/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 177 matching lines @@
 
     static void mark(Visitor*, const T*);
 
 #ifndef NDEBUG
     static void checkTypeMarker(Visitor*, const T*);
 #endif
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
 
+template<typename Collection>
+struct OffHeapCollectionTraceTrait {
+    static void mark(Visitor*, const Collection&);

[haraken, 2014/01/15 04:48:35]

Shouldn't this be "trace" instead of "mark"?

[Erik Corry, 2014/01/15 09:27:32]

Done.

+};
+
 template<typename T>
 struct ObjectAliveTrait {
     static bool isAlive(Visitor*, T);
 };
 
 template<typename T>
 struct ObjectAliveTrait<Member<T> > {
     static bool isAlive(Visitor*, const Member<T>&);
 };
 
@@ skipping 120 matching lines @@
 
 private:
     template<typename T>
     static void handleWeakCell(Visitor* self, void* obj)
     {
         T** cell = reinterpret_cast<T**>(obj);
         if (*cell && !self->isAlive(*cell))
             *cell = 0;
     }
 };
+template<typename T, typename HashFunctions, typename Traits>
+struct OffHeapCollectionTraceTrait<WTF::HashSet<T, WTF::DefaultAllocator, HashFunctions, Traits> > {
+    typedef WTF::HashSet<T, WTF::DefaultAllocator, HashFunctions, Traits> HashSet;
+
+    static void mark(Visitor* v, const HashSet& set)

[haraken, 2014/01/15 04:48:35]

v => visitor

[Erik Corry, 2014/01/15 09:27:32]

Done.

+    {
+        if (set.isEmpty())
+            return;
+        if (WTF::NeedsTracing<T>::value) {
+            for (typename HashSet::const_iterator it = set.begin(), end = set.end(); it != end; ++it)
+                CollectionBackingTraceTrait<Traits::needsTracing, Traits::isWeak, false, T, Traits>::mark(v, *it);
+        }
+        COMPILE_ASSERT(!Traits::isWeak, WeakOffHeapCollectionsConsideredDangerous);
+    }
+};
+
+template<typename T, size_t inlineCapacity, typename HashFunctions>
+struct OffHeapCollectionTraceTrait<WTF::ListHashSet<T, inlineCapacity, HashFunctions> > {
+    typedef WTF::ListHashSet<T, inlineCapacity, HashFunctions> ListHashSet;
+
+    static void mark(Visitor* visitor, const ListHashSet& set)
+    {
+        if (set.isEmpty())
+            return;
+        for (typename ListHashSet::const_iterator it = set.begin(), end = set.end(); it != end; ++it)
+            visitor->trace(*it);
+    }
+};
+
+template<typename Key, typename Value, typename HashFunctions, typename KeyTraits, typename ValueTraits>
+struct OffHeapCollectionTraceTrait<WTF::HashMap<Key, Value, WTF::DefaultAllocator, HashFunctions, KeyTraits, ValueTraits> > {
+    typedef WTF::HashMap<Key, Value, WTF::DefaultAllocator, HashFunctions, KeyTraits, ValueTraits> HashMap;
+
+    static void mark(Visitor* v, const HashMap& map)

[haraken, 2014/01/15 04:48:35]

v => visitor

[Erik Corry, 2014/01/15 09:27:32]

Done.

+    {
+        if (map.isEmpty())
+            return;
+        if (WTF::NeedsTracing<Key>::value || WTF::NeedsTracing<Value>::value) {
+            for (typename HashMap::const_iterator it = map.begin(), end = map.end(); it != end; ++it) {
+                CollectionBackingTraceTrait<KeyTraits::needsTracing, KeyTraits::isWeak, false, Key, KeyTraits>::mark(v, it->key);
+                CollectionBackingTraceTrait<ValueTraits::needsTracing, ValueTraits::isWeak, false, Value, ValueTraits>::mark(v, it->value);
+            }
+        }

[haraken, 2014/01/15 04:48:35]

Shouldn't this be:

for (typename HashMap::const_iterator it = map.begin(), end = map.end(); it !=
end; ++it) {
  if (WTF::NeedsTracing<Key>::value) {
    CollectionBackingTraceTrait<KeyTraits::needsTracing, KeyTraits::isWeak,
false, Key, KeyTraits>::mark(v, it->key);
  }
  if (WTF::NeedsTracing<Value>::value) {
    CollectionBackingTraceTrait<ValueTraits::needsTracing, ValueTraits::isWeak,
false, Value, ValueTraits>::mark(v, it->value);
  }
}

[Erik Corry, 2014/01/15 09:27:32]

This would go through the loop even if nothing needs tracing.  I don't think the
compiler can optimize that away.

The individual if's are not needed inside the loop, since the
CollectionBackingTraceTrait<false,...> will expand to nothing.

+        COMPILE_ASSERT(!KeyTraits::isWeak, WeakOffHeapCollectionsConsideredDangerous);
+        COMPILE_ASSERT(!ValueTraits::isWeak, WeakOffHeapCollectionsConsideredDangerous);
+    }
+};
 
 template<typename T, typename Traits = WTF::VectorTraits<T> >
 class HeapVectorBacking;
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 class HeapHashTableBacking;
 
 // Non-class types like char don't have an trace method, so we provide a more
 // specialized template instantiation here that will be selected in preference
 // to the default. Most of them do nothing, since the type in question cannot
 // point to other heap allocated objects.
@@ skipping 21 matching lines @@
         {                                                      \
             return &info;                                      \
         }                                                      \
         static const GCInfo info;                              \
     };
 
 ITERATE_DO_NOTHING_TYPES(DECLARE_DO_NOTHING_TRAIT)
 
 #undef DECLARE_DO_NOTHING_TRAIT
 
+// Vectors are simple collections, and it's possible to mark vectors in a more
+// general way so that collections of objects (not pointers to objects) can be
+// marked.
+template<typename T, size_t N>
+struct OffHeapCollectionTraceTrait<WTF::Vector<T, N, WTF::DefaultAllocator> > {
+    typedef WTF::Vector<T, N, WTF::DefaultAllocator> Vector;
+
+    static void mark(Visitor* v, const Vector& vector)

[haraken, 2014/01/15 04:48:35]

v => visitor

[Erik Corry, 2014/01/15 09:27:32]

Done.

+    {
+        if (vector.isEmpty())
+            return;
+        for (typename Vector::const_iterator it = vector.begin(), end = vector.end(); it != end; ++it)
+            TraceTrait<T>::trace(v, const_cast<T*>(it));
+    }
+};
+
+// Fallback definition.
+template<typename Collection> void OffHeapCollectionTraceTrait<Collection>::mark(Visitor* visitor, const Collection& collection)
+{
+    if (collection.isEmpty())
+        return;
+    for (typename Collection::const_iterator it = collection.begin(), end = collection.end(); it != end; ++it)
+        visitor->trace(*it);
+}
+
 #ifndef NDEBUG
 template<typename T> void TraceTrait<T>::checkTypeMarker(Visitor* visitor, const T* t)
 {
     visitor->checkTypeMarker(const_cast<T*>(t), getTypeMarker<T>());
 }
 #endif
 
 template<typename T> void TraceTrait<T>::mark(Visitor* visitor, const T* t)
 {
     // Default mark method of the trait just calls the two-argument mark
     // method on the visitor. The second argument is the static trace method
     // of the trait, which by default calls the instance method
     // trace(Visitor*) on the object.
     visitor->mark(const_cast<T*>(t), &trace);
 }
 
 template<typename T> bool ObjectAliveTrait<T>::isAlive(Visitor* visitor, T obj)
 {
     return visitor->isMarked(obj);
 }
 template<typename T> bool ObjectAliveTrait<Member<T> >::isAlive(Visitor* visitor, const Member<T>& obj)
 {
     return visitor->isMarked(obj.raw());
 }
 
 }
 
 #endif