Implement a ScopedThreadHeapUsage class to allow profiling per-thread heap usage.

base/debug/scoped_thread_heap_usage.h

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_DEBUG_SCOPED_THREAD_HEAP_USAGE_H_
+#define BASE_DEBUG_SCOPED_THREAD_HEAP_USAGE_H_
+
+#include <stdint.h>
+
+#include "base/allocator/features.h"
+#include "base/threading/thread_checker.h"
+
+namespace base {
+namespace allocator {
+struct AllocatorDispatch;
+}  // namespace allocator
+
+namespace debug {
+
+// By keeping a tally on heap operations, it's possible to track:
+// - the number of alloc/free operations (realloc is one of each?)

[chrisha, 2016/09/01 20:29:18]

Answer the question before landing this? Is realloc once of each?

[Primiano Tucci (use gerrit), 2016/09/02 17:31:20]

I think conceptually is fine counting realloc as one each because you don't know
what happens for real under the hoods, but very likely growing the allocation
will require a memmove().
All this % the fake reallocs, like realloc(nullptr, 42) which means really
malloc, and realloc(ptr, 0) which means really free. Which should be just
counted as such.

[Sigurður Ásgeirsson, 2016/09/06 14:58:54]

Done.

[Sigurður Ásgeirsson, 2016/09/06 14:58:54]

Done.

+// - the number of bytes allocated/freed.
+// - the number of estimated bytes of heap overhead used.
+// - the high-watermark amount of bytes allocated in the scope.
+// This in turn allows measuring the memory usage and memory usage churn over
+// a scope. Note that scopes must be cleanly nested, and each scope must be
+// destroyed on the thread where it's created.
+class BASE_EXPORT ScopedThreadHeapUsage {
+ public:
+  struct ThreadAllocatorUsage {
+    // The cumulative number of allocation operations.
+    uint64_t alloc_ops;
+
+    // The cumulative number of allocated bytes. Where available, this is
+    // inclusive heap padding and estimated or actual heap overhead.
+    uint64_t alloc_bytes;
+
+    // Where available, cumulative number of heap padding heap
+    // and overhead bytes.
+    uint64_t alloc_overhead_bytes;

[chrisha, 2016/09/01 20:29:17]

Is this ever available? There's no way to get this from the allocator shim API?

[Sigurður Ásgeirsson, 2016/09/06 14:58:54]

It's the difference between the requested size and the estimate on alloc. By
keeping the usage tally in estimate bytes (when available), you can at least
sorta, kinda get the average overhead per alloc in a scope.

+
+    // The cumulative number of free operations.
+    uint64_t free_ops;
+
+    // The cumulative number of bytes freed.
+    // Only recorded if the underlying heap shim can return the size of an
+    // allocation.
+    uint64_t free_bytes;
+
+    // The maximal value of alloc_bytes - free_bytes seen for this thread.
+    // Only recorded if the underlying heap shim supports returning the size of
+    // an allocation.
+    uint64_t max_allocated_bytes;
+  };
+
+  ScopedThreadHeapUsage();
+  ~ScopedThreadHeapUsage();
+
+  const ThreadAllocatorUsage& usage_at_creation() const {
+    return usage_at_creation_;
+  }
+
+  // Returns this thread's current allocator usage.
+  static ThreadAllocatorUsage Now();
+
+  // Initializes the underlying heap shim. Must be called zero or one times.
+  // May only be called if the USE_EXPERIMENTAL_ALLOCATOR_SHIM is enabled.
+  static void Initialize();
+
+ protected:
+  // Exposed for testing only - note that it's safe to re-Initialize() after
+  // tearing down in tests.
+  static void TearDownForTesting();
+  static base::allocator::AllocatorDispatch* GetDispatchForTesting();
+
+ private:
+  static void EnsureTLSInitalized();
+
+  ThreadChecker thread_checker_;
+  // The allocator usage captured at creation of this instance.
+  ThreadAllocatorUsage usage_at_creation_;
+};
+
+}  // namespace debug
+}  // namespace base
+
+#endif  // BASE_DEBUG_SCOPED_THREAD_HEAP_USAGE_H_