Add a UseCounter that measures the amount of memory used in PartitionAlloc

Source/wtf/PartitionAlloc.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 258 matching lines @@
 // An "extent" is a span of consecutive superpages. We link to the partition's
 // next extent (if there is one) at the very start of a superpage's metadata
 // area.
 struct PartitionSuperPageExtentEntry {
     PartitionRootBase* root;
     char* superPageBase;
     char* superPagesEnd;
     PartitionSuperPageExtentEntry* next;
 };
 
+// This callback can be called on any thread.

[Chris Evans, 2015/04/06 04:39:53]

Nit: also document that it's illegal to re-enter PartitionAlloc from within this
callback.

[haraken, 2015/04/06 06:14:14]

Done.

+typedef void (*NotifyCommittedMemoryChangedFunction)();
+
 struct WTF_EXPORT PartitionRootBase {
     size_t totalSizeOfCommittedPages;
     size_t totalSizeOfSuperPages;
     size_t totalSizeOfDirectMappedPages;
     // Invariant: totalSizeOfCommittedPages <= totalSizeOfSuperPages + totalSizeOfDirectMappedPages.
     unsigned numBuckets;
     unsigned maxAllocation;
     bool initialized;
     char* nextSuperPage;
     char* nextPartitionPage;
     char* nextPartitionPageEnd;
     PartitionSuperPageExtentEntry* currentExtent;
     PartitionSuperPageExtentEntry* firstExtent;
     PartitionPage* globalEmptyPageRing[kMaxFreeableSpans];
     int16_t globalEmptyPageRingIndex;
     uintptr_t invertedSelf;
+    NotifyCommittedMemoryChangedFunction notifyCommittedMemoryChangedFunction;
 
     static int gInitializedLock;
     static bool gInitialized;
     // gSeedPage is used as a sentinel to indicate that there is no page
     // in the active page list. We can use nullptr, but in that case we need
     // to add a null-check branch to the hot allocation path. We want to avoid
     // that.
     static PartitionPage gSeedPage;
     static PartitionBucket gPagedBucket;
 };
@@ skipping 17 matching lines @@
     // need to index array[blah][max+1] which risks undefined behavior.
     PartitionBucket* bucketLookups[((kBitsPerSizet + 1) * kGenericNumBucketsPerOrder) + 1];
     PartitionBucket buckets[kGenericNumBucketedOrders * kGenericNumBucketsPerOrder];
 };
 
 // Flags for partitionAllocGenericFlags.
 enum PartitionAllocFlags {
     PartitionAllocReturnNull = 1 << 0,
 };
 
-WTF_EXPORT void partitionAllocInit(PartitionRoot*, size_t numBuckets, size_t maxAllocation);
+WTF_EXPORT void partitionAllocInit(PartitionRoot*, size_t numBuckets, size_t maxAllocation, NotifyCommittedMemoryChangedFunction);
 WTF_EXPORT bool partitionAllocShutdown(PartitionRoot*);
-WTF_EXPORT void partitionAllocGenericInit(PartitionRootGeneric*);
+WTF_EXPORT void partitionAllocGenericInit(PartitionRootGeneric*, NotifyCommittedMemoryChangedFunction);
 WTF_EXPORT bool partitionAllocGenericShutdown(PartitionRootGeneric*);
 
 WTF_EXPORT NEVER_INLINE void* partitionAllocSlowPath(PartitionRootBase*, int, size_t, PartitionBucket*);
 WTF_EXPORT NEVER_INLINE void partitionFreeSlowPath(PartitionPage*);
 WTF_EXPORT NEVER_INLINE void* partitionReallocGeneric(PartitionRootGeneric*, void*, size_t);
 
 #ifndef NDEBUG
 WTF_EXPORT void partitionDumpStats(const PartitionRoot&);
 #endif
 
@@ skipping 315 matching lines @@
 }
 
 // N (or more accurately, N - sizeof(void*)) represents the largest size in
 // bytes that will be handled by a SizeSpecificPartitionAllocator.
 // Attempts to partitionAlloc() more than this amount will fail.
 template <size_t N>
 class SizeSpecificPartitionAllocator {
 public:
     static const size_t kMaxAllocation = N - kAllocationGranularity;
     static const size_t kNumBuckets = N / kAllocationGranularity;
-    void init() { partitionAllocInit(&m_partitionRoot, kNumBuckets, kMaxAllocation); }
+    void init(NotifyCommittedMemoryChangedFunction notifyCommittedMemoryChangedFunction = nullptr)
+    {
+        partitionAllocInit(&m_partitionRoot, kNumBuckets, kMaxAllocation, notifyCommittedMemoryChangedFunction);
+    }
     bool shutdown() { return partitionAllocShutdown(&m_partitionRoot); }
     ALWAYS_INLINE PartitionRoot* root() { return &m_partitionRoot; }
 private:
     PartitionRoot m_partitionRoot;
     PartitionBucket m_actualBuckets[kNumBuckets];
 };
 
 class PartitionAllocatorGeneric {
 public:
-    void init() { partitionAllocGenericInit(&m_partitionRoot); }
+    void init(NotifyCommittedMemoryChangedFunction notifyCommittedMemoryChangedFunction = nullptr)
+    {
+        partitionAllocGenericInit(&m_partitionRoot, notifyCommittedMemoryChangedFunction);
+    }
     bool shutdown() { return partitionAllocGenericShutdown(&m_partitionRoot); }
     ALWAYS_INLINE PartitionRootGeneric* root() { return &m_partitionRoot; }
 private:
     PartitionRootGeneric m_partitionRoot;
 };
 
 } // namespace WTF
 
 using WTF::SizeSpecificPartitionAllocator;
 using WTF::PartitionAllocatorGeneric;
 using WTF::PartitionRoot;
 using WTF::partitionAllocInit;
 using WTF::partitionAllocShutdown;
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
 using WTF::partitionAllocActualSize;
 using WTF::partitionAllocSupportsGetSize;
 using WTF::partitionAllocGetSize;
 
 #endif // WTF_PartitionAlloc_h