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 47 matching lines @@
 // not spread out too much over the address space which would blow
 // away the page tables and lead to bad performance.
 const size_t blinkPagesPerRegion = 10;
 
 // Double precision floats are more efficient when 8 byte aligned, so we 8 byte
 // 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 maxHeapObjectSizeLog2 = 27;
+const size_t maxHeapObjectSize = 1 << maxHeapObjectSizeLog2;
 
 const size_t markBitMask = 1;
 const size_t freeListMask = 2;
 // The dead bit is used for objects that have gone through a GC marking, but did
 // not get swept before a new GC started. In that case we set the dead bit on
 // objects that were not marked in the previous GC to ensure we are not tracing
 // them via a conservatively found pointer. Tracing dead objects could lead to
 // tracing of already finalized objects in another thread's heap which is a
 // use-after-free situation.
 const size_t deadBitMask = 4;
+#if ENABLE(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 & ~static_cast<size_t>(7);
+#else
 const size_t sizeMask = ~static_cast<size_t>(7);
+#endif
 const uint8_t freelistZapValue = 42;
 const uint8_t finalizedZapValue = 24;
 // The orphaned zap value must be zero in the lowest bits to allow for using
 // the mark bit when tracing.
 const uint8_t orphanedZapValue = 240;
 
 enum CallbackInvocationMode {
     GlobalMarking,
     ThreadLocalMarking,
     WeaknessProcessing,
 };
 
 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 ENABLE(GC_PROFILE_HEAP)
+class TracedValue;
+#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 @@
 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 ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfo(Address address)
     {
         if (!objectContains(address))
             return 0;
         return gcInfo();
     }
 #endif
 
+#if ENABLE(GC_PROFILE_HEAP)
+    void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
+#endif
+
     void link(LargeHeapObject<Header>** previousNext)
     {
         m_next = *previousNext;
         *previousNext = this;
     }
 
     void unlink(LargeHeapObject<Header>** previousNext)
     {
         *previousNext = m_next;
     }
@@ skipping 62 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 ENABLE(GC_PROFILE_HEAP)
+    NO_SANITIZE_ADDRESS
+    size_t encodedSize() const { return m_size; }
+
+    NO_SANITIZE_ADDRESS
+    size_t age() const { return m_size >> maxHeapObjectSizeLog2; }
+
+    NO_SANITIZE_ADDRESS
+    void incAge()
+    {
+        size_t current = age();
+        if (current < maxHeapObjectAge)
+            m_size = ((current + 1) << maxHeapObjectSizeLog2) | (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 clearLiveAndMarkDead();
     void sweep();
     void clearObjectStartBitMap();
     void finalize(Header*);
     virtual void checkAndMarkPointer(Visitor*, Address) OVERRIDE;
-#if ENABLE(GC_TRACING)
+#if ENABLE(GC_PROFILE_MARKING)
     const GCInfo* findGCInfo(Address) OVERRIDE;
 #endif
+#if ENABLE(GC_PROFILE_HEAP)
+    virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
+#endif
     ThreadHeap<Header>* heap() { return m_heap; }
 #if defined(ADDRESS_SANITIZER)
     void poisonUnmarkedObjects();
 #endif
     NO_SANITIZE_ADDRESS
     virtual void markOrphaned()
     {
         // Zap the payload with a recognizable value to detect any incorrect
         // cross thread pointer usage.
 #if defined(ADDRESS_SANITIZER)
@@ skipping 309 matching lines @@
 class BaseHeap {
 public:
     virtual ~BaseHeap() { }
     virtual void cleanupPages() = 0;
 
     // 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 ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address) = 0;
 #endif
 
+#if ENABLE(GC_PROFILE_HEAP)
+    virtual void snapshot(TracedValue*, 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;
 
     virtual void clearFreeLists() = 0;
     virtual void clearLiveAndMarkDead() = 0;
 #if ENABLE(ASSERT)
     virtual void getScannedStats(HeapStats&) = 0;
 #endif
 
@@ skipping 19 matching lines @@
 // 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*, int);
     virtual ~ThreadHeap();
     virtual void cleanupPages();
 
     virtual BaseHeapPage* heapPageFromAddress(Address);
-#if ENABLE(GC_TRACING)
+#if ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address);
 #endif
+#if ENABLE(GC_PROFILE_HEAP)
+    virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
+#endif
     virtual void sweep();
     virtual void clearFreeLists();
     virtual void clearLiveAndMarkDead();
 #if ENABLE(ASSERT)
     virtual void getScannedStats(HeapStats&);
 #endif
 
     virtual void makeConsistentForGC();
     virtual bool isConsistentForGC();
 
@@ skipping 107 matching lines @@
     template<CallbackInvocationMode Mode> static void processMarkingStack();
     static void globalWeakProcessingAndCleanup();
     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 ENABLE(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 833 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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 template<typename T>
 struct GCInfoTrait<Vector<T, 0, HeapAllocator> > {
     static const GCInfo* get()
     {
-#if ENABLE(GC_TRACING)
+#if ENABLE(GC_PROFILING)
         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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             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 ENABLE(GC_PROFILING)
             TypenameStringTrait<TargetType>::get()
 #endif
         };
         return &info;
     }
 };
 
 } // namespace blink
 
 namespace WTF {
@@ skipping 323 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