Oilpan: GC profiling.

Source/platform/heap/Heap.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 52 matching lines @@
 // align all allocations even on 32 bit.
 const size_t allocationGranularity = 8;
 const size_t allocationMask = allocationGranularity - 1;
 const size_t objectStartBitMapSize = (blinkPageSize + ((8 * allocationGranularity) - 1)) / (8 * allocationGranularity);
 const size_t reservedForObjectBitMap = ((objectStartBitMapSize + allocationMask) & ~allocationMask);
 const size_t maxHeapObjectSize = 1 << 27;
 
 const size_t markBitMask = 1;
 const size_t freeListMask = 2;
 const size_t debugBitMask = 4;
+#if GC_PROFILE_HEAP
+const size_t heapObjectGenerations = 8;
+const size_t maxHeapObjectAge = heapObjectGenerations - 1;
+const size_t heapObjectAgeMask = ~(maxHeapObjectSize - 1);
+const size_t sizeMask = ~heapObjectAgeMask & ~7;
+#else
 const size_t sizeMask = ~7;
+#endif
 const uint8_t freelistZapValue = 42;
 const uint8_t finalizedZapValue = 24;
 
 class HeapStats;
 class PageMemory;
 template<ThreadAffinity affinity> class ThreadLocalPersistents;
 template<typename T, typename RootsAccessor = ThreadLocalPersistents<ThreadingTrait<T>::Affinity > > class Persistent;
 template<typename T> class CrossThreadPersistent;
 
+#if GC_PROFILE_HEAP
+class TracedArrayBase;
+class TracedDictionaryBase;
+#endif
+
 PLATFORM_EXPORT size_t osPageSize();
 
 // Blink heap pages are set up with a guard page before and after the
 // payload.
 inline size_t blinkPagePayloadSize()
 {
     return blinkPageSize - 2 * osPageSize();
 }
 
 // Blink heap pages are aligned to the Blink heap page size.
@@ skipping 58 matching lines @@
     // 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;
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     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; }
 
 private:
@@ skipping 23 matching lines @@
 class LargeHeapObject : public BaseHeapPage {
 public:
     LargeHeapObject(PageMemory* storage, const GCInfo* gcInfo, ThreadState* state) : BaseHeapPage(storage, gcInfo, state)
     {
         COMPILE_ASSERT(!(sizeof(LargeHeapObject<Header>) & allocationMask), large_heap_object_header_misaligned);
     }
 
     virtual void checkAndMarkPointer(Visitor*, Address) OVERRIDE;
     virtual bool isLargeObject() OVERRIDE { return true; }
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     virtual const GCInfo* findGCInfo(Address address)
     {
         if (!objectContains(address))
             return 0;
         return gcInfo();
     }
 #endif
 
+#if GC_PROFILE_HEAP
+    void snapshot(TracedDictionaryBase*, ThreadState::SnapshotInfo*);
+#endif
+
     void link(LargeHeapObject<Header>** previousNext)
     {
         m_next = *previousNext;
         *previousNext = this;
     }
 
     void unlink(LargeHeapObject<Header>** previousNext)
     {
         *previousNext = m_next;
     }
@@ skipping 54 matching lines @@
         : m_size(encodedSize) { }
 
     static size_t freeListEncodedSize(size_t size) { return size | freeListMask; }
 
     NO_SANITIZE_ADDRESS
     bool isFree() { return m_size & freeListMask; }
 
     NO_SANITIZE_ADDRESS
     size_t size() const { return m_size & sizeMask; }
 
+#if GC_PROFILE_HEAP
+    NO_SANITIZE_ADDRESS
+    size_t encodedSize() const { return m_size; }
+
+    NO_SANITIZE_ADDRESS
+    size_t age() const { return m_size >> 27; }

[haraken, 2014/07/14 02:26:14]

Can we avoid hard-coding 27?

[zerny-chromium, 2014/07/28 11:54:41]

Done.

+
+    NO_SANITIZE_ADDRESS
+    void incAge()
+    {
+        size_t current = age();
+        if (current < 7)
+            m_size = ((current + 1) << 27) | (m_size & ~heapObjectAgeMask);
+    }
+#endif
+
 protected:
     size_t m_size;
 };
 
 // Our heap object layout is layered with the HeapObjectHeader closest
 // to the payload, this can be wrapped in a FinalizedObjectHeader if the
 // object is on the GeneralHeap and not on a specific TypedHeap.
 // Finally if the object is a large object (> blinkPageSize/2) then it is
 // wrapped with a LargeObjectHeader.
 //
@@ skipping 190 matching lines @@
     }
 
     Address end() { return payload() + payloadSize(); }
 
     void getStats(HeapStats&);
     void clearMarks();
     void sweep();
     void clearObjectStartBitMap();
     void finalize(Header*);
     virtual void checkAndMarkPointer(Visitor*, Address) OVERRIDE;
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     const GCInfo* findGCInfo(Address) OVERRIDE;
 #endif
+#if GC_PROFILE_HEAP
+    virtual void snapshot(TracedArrayBase*, ThreadState::SnapshotInfo*);
+#endif
     ThreadHeap<Header>* heap() { return m_heap; }
 #if defined(ADDRESS_SANITIZER)
     void poisonUnmarkedObjects();
 #endif
 
 protected:
     Header* findHeaderFromAddress(Address);
     void populateObjectStartBitMap();
     bool isObjectStartBitMapComputed() { return m_objectStartBitMapComputed; }
     TraceCallback traceCallback(Header*);
@@ skipping 243 matching lines @@
 // Non-template super class used to pass a heap around to other classes.
 class BaseHeap {
 public:
     virtual ~BaseHeap() { }
 
     // Find the page in this thread heap containing the given
     // address. Returns 0 if the address is not contained in any
     // page in this thread heap.
     virtual BaseHeapPage* heapPageFromAddress(Address) = 0;
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address) = 0;
 #endif
 
+#if GC_PROFILE_HEAP
+    virtual void snapshot(TracedDictionaryBase*, ThreadState::SnapshotInfo*) = 0;
+#endif
+
     // Sweep this part of the Blink heap. This finalizes dead objects
     // and builds freelists for all the unused memory.
     virtual void sweep() = 0;
 
     // Forcefully finalize all objects in this part of the Blink heap
     // (potentially with the exception of one object). This is used
     // during thread termination to make sure that all objects for the
     // dying thread are finalized.
     virtual void assertEmpty() = 0;
 
@@ skipping 22 matching lines @@
 // (potentially adding new pages to the heap), to find and mark
 // objects during conservative stack scanning and to sweep the set of
 // pages after a GC.
 template<typename Header>
 class ThreadHeap : public BaseHeap {
 public:
     ThreadHeap(ThreadState*);
     virtual ~ThreadHeap();
 
     virtual BaseHeapPage* heapPageFromAddress(Address);
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address);
 #endif
+#if GC_PROFILE_HEAP
+    virtual void snapshot(TracedDictionaryBase*, ThreadState::SnapshotInfo*);
+#endif
     virtual void sweep();
     virtual void assertEmpty();
     virtual void clearFreeLists();
     virtual void clearMarks();
 #ifndef NDEBUG
     virtual void getScannedStats(HeapStats&);
 #endif
 
     virtual void makeConsistentForGC();
     virtual bool isConsistentForGC();
@@ skipping 129 matching lines @@
     static void collectGarbage(ThreadState::StackState);
     static void collectAllGarbage();
     static void setForcePreciseGCForTesting();
 
     static void prepareForGC();
 
     // Conservatively checks whether an address is a pointer in any of the thread
     // heaps. If so marks the object pointed to as live.
     static Address checkAndMarkPointer(Visitor*, Address);
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     // Dump the path to specified object on the next GC. This method is to be invoked from GDB.
     static void dumpPathToObjectOnNextGC(void* p);
 
     // Forcibly find GCInfo of the object at Address.
     // This is slow and should only be used for debug purposes.
     // It involves finding the heap page and scanning the heap page for an object header.
     static const GCInfo* findGCInfo(Address);
 
     static String createBacktraceString();
 #endif
@@ skipping 820 matching lines @@
 template<typename Key, typename Value, typename T, typename U, typename V>
 struct GCInfoTrait<HashMap<Key, Value, T, U, V, HeapAllocator> > {
     static const GCInfo* get()
     {
         typedef HashMap<Key, Value, T, U, V, HeapAllocator> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             0,
             false, // HashMap needs no finalizer.
             WTF::IsPolymorphic<TargetType>::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HashSet<T, U, V, HeapAllocator> > {
     static const GCInfo* get()
     {
         typedef HashSet<T, U, V, HeapAllocator> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             0,
             false, // HashSet needs no finalizer.
             WTF::IsPolymorphic<TargetType>::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename T, typename U, typename V>
 struct GCInfoTrait<LinkedHashSet<T, U, V, HeapAllocator> > {
     static const GCInfo* get()
     {
         typedef LinkedHashSet<T, U, V, HeapAllocator> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             LinkedHashSet<T, U, V, HeapAllocator>::finalize,
             true, // Needs finalization. The anchor needs to unlink itself from the chain.
             WTF::IsPolymorphic<TargetType>::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename ValueArg, size_t inlineCapacity, typename U>
 struct GCInfoTrait<ListHashSet<ValueArg, inlineCapacity, U, HeapListHashSetAllocator<ValueArg, inlineCapacity> > > {
     static const GCInfo* get()
     {
         typedef WTF::ListHashSet<ValueArg, inlineCapacity, U, HeapListHashSetAllocator<ValueArg, inlineCapacity> > TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             0,
             false, // ListHashSet needs no finalization though its backing might.
             false, // no vtable.
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename T, typename Allocator>
 struct GCInfoTrait<WTF::ListHashSetNode<T, Allocator> > {
     static const GCInfo* get()
     {
         typedef WTF::ListHashSetNode<T, Allocator> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             TargetType::finalize,
             WTF::HashTraits<T>::needsDestruction, // The node needs destruction if its data does.
             false, // no vtable.
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename T>
 struct GCInfoTrait<Vector<T, 0, HeapAllocator> > {
     static const GCInfo* get()
     {
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
         typedef Vector<T, 0, HeapAllocator> TargetType;
 #endif
         static const GCInfo info = {
             TraceTrait<Vector<T, 0, HeapAllocator> >::trace,
             0,
             false, // Vector needs no finalizer if it has no inline capacity.
             WTF::IsPolymorphic<Vector<T, 0, HeapAllocator> >::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename T, size_t inlineCapacity>
 struct FinalizerTrait<Vector<T, inlineCapacity, HeapAllocator> > : public FinalizerTraitImpl<Vector<T, inlineCapacity, HeapAllocator>, true> { };
 
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> > {
     static const GCInfo* get()
     {
         typedef Vector<T, inlineCapacity, HeapAllocator> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             FinalizerTrait<TargetType>::finalize,
             // Finalizer is needed to destruct things stored in the inline capacity.
             inlineCapacity && VectorTraits<T>::needsDestruction,
             WTF::IsPolymorphic<TargetType>::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename T>
 struct GCInfoTrait<Deque<T, 0, HeapAllocator> > {
     static const GCInfo* get()
     {
         typedef Deque<T, 0, HeapAllocator> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             0,
             false, // Deque needs no finalizer if it has no inline capacity.
             WTF::IsPolymorphic<TargetType>::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
     static const GCInfo info;
 };
 
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator> > {
     static const GCInfo* get()
     {
         typedef HashCountedSet<T, U, V, HeapAllocator> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             0,
             false, // HashCountedSet is just a HashTable, and needs no finalizer.
             WTF::IsPolymorphic<TargetType>::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
     static const GCInfo info;
 };
 
 template<typename T, size_t inlineCapacity>
 struct FinalizerTrait<Deque<T, inlineCapacity, HeapAllocator> > : public FinalizerTraitImpl<Deque<T, inlineCapacity, HeapAllocator>, true> { };
 
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator> > {
     static const GCInfo* get()
     {
         typedef Deque<T, inlineCapacity, HeapAllocator> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             FinalizerTrait<TargetType>::finalize,
             // Finalizer is needed to destruct things stored in the inline capacity.
             inlineCapacity && VectorTraits<T>::needsDestruction,
             WTF::IsPolymorphic<TargetType>::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
     static const GCInfo info;
 };
 
 template<typename T, typename Traits>
 struct GCInfoTrait<HeapVectorBacking<T, Traits> > {
     static const GCInfo* get()
     {
         typedef HeapVectorBacking<T, Traits> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             FinalizerTrait<TargetType>::finalize,
             Traits::needsDestruction,
             false, // We don't support embedded objects in HeapVectors with vtables.
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename Table>
 struct GCInfoTrait<HeapHashTableBacking<Table> > {
     static const GCInfo* get()
     {
         typedef HeapHashTableBacking<Table> TargetType;
         static const GCInfo info = {
             TraceTrait<TargetType>::trace,
             HeapHashTableBacking<Table>::finalize,
             Table::ValueTraits::needsDestruction,
             WTF::IsPolymorphic<TargetType>::value,
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_DEFINE_CLASSNAME
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 } // namespace WebCore
 
 namespace WTF {
@@ skipping 322 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 }
 
 #endif // Heap_h