Profile FreeList

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 63 matching lines @@
 // 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;
 // On free-list entries we reuse the dead bit to distinguish a normal free-list
 // entry from one that has been promptly freed.
 const size_t promptlyFreedMask = freeListMask | deadBitMask;
-#if ENABLE(GC_PROFILE_HEAP)
+//#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
+//#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;
 const int numberOfPagesToConsiderForCoalescing = 100;
 
 enum CallbackInvocationMode {
     GlobalMarking,
     ThreadLocalMarking,
 };
 
 class CallbackStack;
 class PageMemory;
 template<ThreadAffinity affinity> class ThreadLocalPersistents;
 template<typename T, typename RootsAccessor = ThreadLocalPersistents<ThreadingTrait<T>::Affinity > > class Persistent;
 
-#if ENABLE(GC_PROFILE_HEAP)
+#if ENABLE(GC_PROFILE_HEAP) || ENABLE(GC_PROFILE_FREE_LIST)
 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();
@@ skipping 165 matching lines @@
 
     NO_SANITIZE_ADDRESS
     void markPromptlyFreed() { m_size |= promptlyFreedMask; }
 
     NO_SANITIZE_ADDRESS
     size_t size() const { return m_size & sizeMask; }
 
     NO_SANITIZE_ADDRESS
     void setSize(size_t size) { m_size = (size | (m_size & ~sizeMask)); }
 
-#if ENABLE(GC_PROFILE_HEAP)
+    //#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
+    //#endif
 
 protected:
     volatile unsigned 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 207 matching lines @@
     void clearObjectStartBitMap();
     void finalize(Header*);
     virtual void checkAndMarkPointer(Visitor*, Address) override;
 #if ENABLE(GC_PROFILE_MARKING)
     const GCInfo* findGCInfo(Address) override;
 #endif
 #if ENABLE(GC_PROFILE_HEAP)
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
 #endif
 
+    void countUnmarkedObjects();
+
 #if defined(ADDRESS_SANITIZER)
     void poisonUnmarkedObjects();
 #endif
     NO_SANITIZE_ADDRESS
     virtual void markOrphaned() override
     {
         // Zap the payload with a recognizable value to detect any incorrect
         // cross thread pointer usage.
 #if defined(ADDRESS_SANITIZER)
         // Don't use memset when running with ASan since this needs to zap
@@ skipping 130 matching lines @@
 
     // 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* pageFromAddress(Address) = 0;
 
 #if ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfoOfLargeObject(Address) = 0;
 #endif
 
+#if ENABLE(GC_PROFILE_FREE_LIST)
+    virtual void snapshotFreeList(TracedValue*) = 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 postSweepProcessing() = 0;
 
     virtual void clearFreeLists() = 0;
@@ skipping 13 matching lines @@
 };
 
 template<typename Header>
 class FreeList {
 public:
     FreeList();
 
     void addToFreeList(Address, size_t);
     void clear();
 
+#if ENABLE(GC_PROFILE_FREE_LIST)
+    void countBucketSizes(size_t[], size_t[], size_t* freeSize) const;
+#endif
+
 private:
     // Returns a bucket number for inserting a FreeListEntry of a
     // given size. All FreeListEntries in the given bucket, n, have
     // size >= 2^n.
     static int bucketIndexForSize(size_t);
 
     int m_biggestFreeListIndex;
 
     // All FreeListEntries in the nth list have size >= 2^n.
     FreeListEntry* m_freeLists[blinkPageSizeLog2];
@@ skipping 16 matching lines @@
 class ThreadHeap : public BaseHeap {
 public:
     ThreadHeap(ThreadState*, int);
     virtual ~ThreadHeap();
     virtual void cleanupPages() override;
 
     virtual BaseHeapPage* pageFromAddress(Address) override;
 #if ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfoOfLargeObject(Address) override;
 #endif
+#if ENABLE(GC_PROFILE_FREE_LIST)
+    virtual void snapshotFreeList(TracedValue*) override;
+#endif
 #if ENABLE(GC_PROFILE_HEAP)
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
 #endif
 
     virtual void sweep() override;
     virtual void postSweepProcessing() override;
 
     virtual void clearFreeLists() override;
     virtual void markUnmarkedObjectsDead() override;
 
@@ skipping 32 matching lines @@
 private:
     void addPageToHeap(const GCInfo*);
     PLATFORM_EXPORT Address outOfLineAllocate(size_t payloadSize, size_t allocationSize, const GCInfo*);
     static size_t allocationSizeFromSize(size_t);
     PLATFORM_EXPORT Address allocateLargeObject(size_t, const GCInfo*);
     Address currentAllocationPoint() const { return m_currentAllocationPoint; }
     size_t remainingAllocationSize() const { return m_remainingAllocationSize; }
     bool ownsNonEmptyAllocationArea() const { return currentAllocationPoint() && remainingAllocationSize(); }
     void setAllocationPoint(Address point, size_t size)
     {
+#if ENABLE(GC_PROFILE_FREE_LIST)
+        m_allocationPointSizeSum += size;
+        ++m_setAllocationPointCount;
+#endif
         ASSERT(!point || pageFromAddress(point));
         ASSERT(size <= HeapPage<Header>::payloadSize());
         updateRemainingAllocationSize();
         m_currentAllocationPoint = point;
         m_lastRemainingAllocationSize = m_remainingAllocationSize = size;
     }
     void ensureCurrentAllocation(size_t, const GCInfo*);
     bool allocateFromFreeList(size_t);
 
     void freeLargeObject(LargeObject<Header>*, LargeObject<Header>**);
     void allocatePage(const GCInfo*);
 
 #if ENABLE(ASSERT)
     bool pagesToBeSweptContains(Address);
     bool pagesAllocatedDuringSweepingContains(Address);
 #endif
 
     void sweepNormalPages();
     void sweepLargePages();
     bool coalesce(size_t);
 
     Address m_currentAllocationPoint;
     size_t m_remainingAllocationSize;
     size_t m_lastRemainingAllocationSize;
 
+    double m_totalAllocationSize;
+    size_t m_allocationCount;
+    size_t m_inlineAllocationCount;
+
     HeapPage<Header>* m_firstPage;
     LargeObject<Header>* m_firstLargeObject;
 
     HeapPage<Header>* m_firstPageAllocatedDuringSweeping;
     HeapPage<Header>* m_lastPageAllocatedDuringSweeping;
 
     LargeObject<Header>* m_firstLargeObjectAllocatedDuringSweeping;
     LargeObject<Header>* m_lastLargeObjectAllocatedDuringSweeping;
 
     ThreadState* m_threadState;
 
     FreeList<Header> m_freeList;
 
     // Index into the page pools. This is used to ensure that the pages of the
     // same type go into the correct page pool and thus avoid type confusion.
     int m_index;
 
     int m_numberOfNormalPages;
 
     // The promptly freed count contains the number of promptly freed objects
     // since the last sweep or since it was manually reset to delay coalescing.
     size_t m_promptlyFreedCount;
+
+#if ENABLE(GC_PROFILE_FREE_LIST)
+    size_t m_allocationPointSizeSum = 0;
+    size_t m_setAllocationPointCount = 0;
+#endif
 };
 
 class PLATFORM_EXPORT Heap {
 public:
     static void init();
     static void shutdown();
     static void doShutdown();
 
     static BaseHeapPage* contains(Address);
     static BaseHeapPage* contains(void* pointer) { return contains(reinterpret_cast<Address>(pointer)); }
@@ skipping 53 matching lines @@
     static void collectGarbage(ThreadState::StackState, ThreadState::CauseOfGC = ThreadState::NormalGC);
     static void collectGarbageForTerminatingThread(ThreadState*);
     static void collectAllGarbage();
     template<CallbackInvocationMode Mode> static void processMarkingStack();
     static void postMarkingProcessing();
     static void globalWeakProcessing();
     static void setForcePreciseGCForTesting();
 
     static void prepareForGC();
 
+    static void reportSweepingStats();
+
     // 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_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.
@@ skipping 395 matching lines @@
     // Add space for header.
     size_t allocationSize = size + sizeof(Header);
     // Align size with allocation granularity.
     allocationSize = (allocationSize + allocationMask) & ~allocationMask;
     return allocationSize;
 }
 
 template<typename Header>
 Address ThreadHeap<Header>::allocate(size_t size, const GCInfo* gcInfo)
 {
+    m_totalAllocationSize += size;
+    m_allocationCount++;
     size_t allocationSize = allocationSizeFromSize(size);
     if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
+        m_inlineAllocationCount++;
         Address headerAddress = m_currentAllocationPoint;
         m_currentAllocationPoint += allocationSize;
         m_remainingAllocationSize -= allocationSize;
         new (NotNull, headerAddress) Header(allocationSize, gcInfo);
         Address result = headerAddress + sizeof(Header);
         ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
 
         // Unpoison the memory used for the object (payload).
         ASAN_UNPOISON_MEMORY_REGION(result, allocationSize - sizeof(Header));
 #if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
@@ skipping 997 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity> > : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity> > : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator> > { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V> > : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator> > { };
 
 } // namespace blink
 
 #endif // Heap_h