Oilpan: Add free list profiler.

Source/platform/heap/ThreadState.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 511 matching lines @@
         // For i == 7, the count is the number of objects that survived at least 7 GCs.
         using GenerationCountsVector = Vector<int, numberOfGenerationsToTrack>;
         Vector<GenerationCountsVector> generations;
 
         explicit SnapshotInfo(ThreadState* state) : state(state), freeSize(0), pageCount(0) { }
 
         size_t getClassTag(const GCInfo*);
     };
 
     void snapshot();
+
+    void snapshotFreeListIfNecessary();
 #endif
 
     void pushWeakPointerCallback(void*, WeakPointerCallback);
     bool popAndInvokeWeakPointerCallback(Visitor*);
 
     size_t objectPayloadSizeForTesting();
 
     void postGCProcessing();
     void prepareHeapForTermination();
 
@@ skipping 64 matching lines @@
     // to sweep away any objects that are left on this heap.
     // We assert that nothing must remain after this cleanup.
     // If assertion does not hold we crash as we are potentially
     // in the dangling pointer situation.
     void cleanup();
     void cleanupPages();
 
     void unregisterPreFinalizerInternal(void*);
     void invokePreFinalizers(Visitor&);
 
+#if ENABLE(GC_PROFILING)
+    void snapshotFreeList();
+#endif
+
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static uintptr_t s_mainThreadStackStart;
     static uintptr_t s_mainThreadUnderestimatedStackSize;
     static SafePointBarrier* s_safePointBarrier;
 
     // We can't create a static member of type ThreadState here
     // because it will introduce global constructor and destructor.
     // We would like to manage lifetime of the ThreadState attached
     // to the main thread explicitly instead and still use normal
     // constructor and destructor for the ThreadState class.
@@ skipping 27 matching lines @@
     HashMap<void*, bool (*)(void*, Visitor&)> m_preFinalizers;
 
     v8::Isolate* m_isolate;
     void (*m_traceDOMWrappers)(v8::Isolate*, Visitor*);
 
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
 
     Vector<PageMemoryRegion*> m_allocatedRegionsSinceLastGC;
+
+#if ENABLE(GC_PROFILING)
+    double m_nextFreeListSnapshotTime;
+#endif
 };
 
 template<ThreadAffinity affinity> class ThreadStateFor;
 
 template<> class ThreadStateFor<MainThreadOnly> {
 public:
     static ThreadState* state()
     {
         // This specialization must only be used from the main thread.
         ASSERT(ThreadState::current()->isMainThread());
@@ skipping 57 matching lines @@
         m_locked = false;
     }
 
     MutexBase& m_mutex;
     bool m_locked;
 };
 
 } // namespace blink
 
 #endif // ThreadState_h