Add heap allocator usage to task profiler.

base/debug/scoped_thread_heap_usage.cc

 // 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.
 
 #include "base/debug/scoped_thread_heap_usage.h"
 
+#include <windows.h>
+

[Primiano Tucci (use gerrit), 2016/10/13 20:47:44]

if defined(OS_WINDOWS) ?? (but then you need build_config first)

[Sigurður Ásgeirsson, 2016/10/14 13:23:47]

Thanks, this is debugging remnants - <windows.h> has no business here. Gone!

 #include <stdint.h>
 #include <algorithm>
 #include <type_traits>
 
 #include "base/allocator/allocator_shim.h"
 #include "base/allocator/features.h"
 #include "base/logging.h"
 #include "base/threading/thread_local_storage.h"
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX) || defined(OS_IOS)
 #include <malloc/malloc.h>
 #else
 #include <malloc.h>
 #endif
 
 namespace base {
 namespace debug {
 
 namespace {
 
 using base::allocator::AllocatorDispatch;
 
 ThreadLocalStorage::StaticSlot g_thread_allocator_usage = TLS_INITIALIZER;
 
-ScopedThreadHeapUsage::ThreadAllocatorUsage* const kInitializingSentinel =
-    reinterpret_cast<ScopedThreadHeapUsage::ThreadAllocatorUsage*>(-1);
+ThreadAllocatorUsage* const kInitializingSentinel =
+    reinterpret_cast<ThreadAllocatorUsage*>(-1);
 
 bool g_heap_tracking_enabled = false;
 
 // Forward declared as it needs to delegate memory allocation to the next
 // lower shim.
-ScopedThreadHeapUsage::ThreadAllocatorUsage* GetOrCreateThreadUsage();
+ThreadAllocatorUsage* GetOrCreateThreadUsage();
 
 size_t GetAllocSizeEstimate(const AllocatorDispatch* next, void* ptr) {
   if (ptr == nullptr)
     return 0U;
 
   return next->get_size_estimate_function(next, ptr);
 }
 
 void RecordAlloc(const AllocatorDispatch* next, void* ptr, size_t size) {
-  ScopedThreadHeapUsage::ThreadAllocatorUsage* usage = GetOrCreateThreadUsage();
+  ThreadAllocatorUsage* usage = GetOrCreateThreadUsage();
   if (usage == nullptr)
     return;
 
   usage->alloc_ops++;
   size_t estimate = GetAllocSizeEstimate(next, ptr);
   if (size && estimate) {
+    // Only keep track of the net number of bytes allocated in the scope if the
+    // size estimate function returns sane values, e.g. non-zero.
     usage->alloc_bytes += estimate;
     usage->alloc_overhead_bytes += estimate - size;
 
-    // Only keep track of the net number of bytes allocated in the scope if the
-    // size estimate function returns sane values, e.g. non-zero.
-    uint64_t allocated_bytes = usage->alloc_bytes - usage->free_bytes;
-    if (allocated_bytes > usage->max_allocated_bytes)
-      usage->max_allocated_bytes = allocated_bytes;
+    // Record the max outstanding number of bytes, but only if the difference
+    // is net positive (e.g. more bytes allocated than freed in the scope).
+    if (usage->alloc_bytes > usage->free_bytes) {
+      uint64_t allocated_bytes = usage->alloc_bytes - usage->free_bytes;
+      if (allocated_bytes > usage->max_allocated_bytes)
+        usage->max_allocated_bytes = allocated_bytes;
+    }
   } else {
     usage->alloc_bytes += size;
   }
 }
 
 void RecordFree(const AllocatorDispatch* next, void* ptr) {
-  ScopedThreadHeapUsage::ThreadAllocatorUsage* usage = GetOrCreateThreadUsage();
+  ThreadAllocatorUsage* usage = GetOrCreateThreadUsage();
   if (usage == nullptr)
     return;
 
   size_t estimate = GetAllocSizeEstimate(next, ptr);
   usage->free_ops++;
   usage->free_bytes += estimate;
 }
 
 void* AllocFn(const AllocatorDispatch* self, size_t size) {
   void* ret = self->next->alloc_function(self->next, size);
@@ skipping 42 matching lines @@
 
 size_t GetSizeEstimateFn(const AllocatorDispatch* self, void* address) {
   return self->next->get_size_estimate_function(self->next, address);
 }
 
 // The allocator dispatch used to intercept heap operations.
 AllocatorDispatch allocator_dispatch = {
     &AllocFn, &AllocZeroInitializedFn, &AllocAlignedFn, &ReallocFn,
     &FreeFn,  &GetSizeEstimateFn,      nullptr};
 
-ScopedThreadHeapUsage::ThreadAllocatorUsage* GetOrCreateThreadUsage() {
-  ScopedThreadHeapUsage::ThreadAllocatorUsage* allocator_usage =
-      static_cast<ScopedThreadHeapUsage::ThreadAllocatorUsage*>(
-          g_thread_allocator_usage.Get());
+ThreadAllocatorUsage* GetOrCreateThreadUsage() {
+  // DO NOT SUBMIT!
+  if (!g_thread_allocator_usage.initialized())

[Primiano Tucci (use gerrit), 2016/10/13 20:47:44]

uh? Shouldn't just you initialize this in some main? I guess this is the reason
of that "DO NOT SUBMIT"?

[Sigurður Ásgeirsson, 2016/10/14 20:11:35]

Sorry, more debugging remnants.

+    return nullptr;
+
+  ThreadAllocatorUsage* allocator_usage =
+      static_cast<ThreadAllocatorUsage*>(g_thread_allocator_usage.Get());
   if (allocator_usage == kInitializingSentinel)
     return nullptr;  // Re-entrancy case.
 
   if (allocator_usage == nullptr) {
     // Prevent reentrancy due to the allocation below.
     g_thread_allocator_usage.Set(kInitializingSentinel);
 
-    allocator_usage = new ScopedThreadHeapUsage::ThreadAllocatorUsage;
+    allocator_usage = new ThreadAllocatorUsage;
     memset(allocator_usage, 0, sizeof(*allocator_usage));
     g_thread_allocator_usage.Set(allocator_usage);
   }
 
   return allocator_usage;
 }
 
 }  // namespace
 
-ScopedThreadHeapUsage::ScopedThreadHeapUsage() {
-  // Initialize must be called before creating instances of this class.
-  CHECK(g_thread_allocator_usage.initialized());
+HeapUsageTracker::HeapUsageTracker() : thread_usage_(nullptr) {
+  static_assert(std::is_pod<ThreadAllocatorUsage>::value, "Must be POD.");
+}
 
-  ThreadAllocatorUsage* usage = GetOrCreateThreadUsage();
-  usage_at_creation_ = *usage;
+HeapUsageTracker::~HeapUsageTracker() {
+  // If this is called, weirdness happens in Chrome's state at large.
+  // CHECK(thread_checker_.CalledOnValidThread());

[Primiano Tucci (use gerrit), 2016/10/13 20:47:44]

Please tell me you did never hit this CHECK :)

[Sigurður Ásgeirsson, 2016/10/14 20:11:35]

No, it just wrecked Chrome's state to the point where youtube.com was
accessible, but slashdot.org wasn't :/

+}
+
+void HeapUsageTracker::Start() {
+  // TODO(siggi): Grrrr - more usable this way.
+  if (!g_thread_allocator_usage.initialized())

[Primiano Tucci (use gerrit), 2016/10/13 20:47:44]

hmm the TLS slot itself should be initialzied only once per all int he process.
how do you end up in this state?

[Sigurður Ásgeirsson, 2016/10/14 20:11:35]

Yeah, I'm not sure what's the right way to do this. The thing is that as this
bakes into existing instrumentation, either I mandate a check before using
Start/Stop, or else I noop them when off.

+    return;
+
+  DCHECK(g_thread_allocator_usage.initialized());
+
+  thread_usage_ = GetOrCreateThreadUsage();
+  DCHECK_NE(nullptr, thread_usage_);

[Primiano Tucci (use gerrit), 2016/10/13 20:47:44]

well, even without this dcheck, if this happens to be null it will fail on the
next line.

[Sigurður Ásgeirsson, 2016/10/14 20:11:35]

Done.

+
+  usage_ = *thread_usage_;
 
   // Reset the stats for our current scope.
   // The per-thread usage instance now tracks this scope's usage, while this
   // instance persists the outer scope's usage stats. On destruction, this
-  // instance will restore the outer scope's usage stats with this scope's usage
-  // added.
-  memset(usage, 0, sizeof(*usage));
-
-  static_assert(std::is_pod<ThreadAllocatorUsage>::value, "Must be POD.");
+  // instance will restore the outer scope's usage stats with this scope's
+  // usage added.
+  memset(thread_usage_, 0, sizeof(*thread_usage_));
 }
 
-ScopedThreadHeapUsage::~ScopedThreadHeapUsage() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+void HeapUsageTracker::Stop(bool usage_is_exclusive) {
+  // TODO(siggi): Grrrr - more usable this way.
+  if (thread_usage_ == nullptr) {
+    memset(&usage_, 0, sizeof(usage_));
+    return;
+  }
+
+  DCHECK_NE(nullptr, thread_usage_);
+
+  ThreadAllocatorUsage current = CurrentUsage();
+  if (usage_is_exclusive) {
+    *thread_usage_ = usage_;
+  } else {
+    // Update the outer max.
+    if (thread_usage_->max_allocated_bytes) {
+      uint64_t outer_net_alloc_bytes = usage_.alloc_bytes - usage_.free_bytes;
+
+      thread_usage_->max_allocated_bytes =
+          std::max(usage_.max_allocated_bytes,
+                   outer_net_alloc_bytes + thread_usage_->max_allocated_bytes);
+    }
+
+    thread_usage_->alloc_ops += usage_.alloc_ops;
+    thread_usage_->alloc_bytes += usage_.alloc_bytes;
+    thread_usage_->alloc_overhead_bytes += usage_.alloc_overhead_bytes;
+    thread_usage_->free_ops += usage_.free_ops;
+    thread_usage_->free_bytes += usage_.free_bytes;
+  }
+
+  usage_ = current;
+}
+
+ThreadAllocatorUsage HeapUsageTracker::CurrentUsage() {
+  DCHECK(g_thread_allocator_usage.initialized());
 
   ThreadAllocatorUsage* usage = GetOrCreateThreadUsage();
-
-  // Update the outer max.
-  if (usage->max_allocated_bytes) {
-    uint64_t outer_net_alloc_bytes =
-        usage_at_creation_.alloc_bytes - usage_at_creation_.free_bytes;
-
-    usage->max_allocated_bytes =
-        std::max(usage_at_creation_.max_allocated_bytes,
-                 outer_net_alloc_bytes + usage->max_allocated_bytes);
-  }
-
-  usage->alloc_ops += usage_at_creation_.alloc_ops;
-  usage->alloc_bytes += usage_at_creation_.alloc_bytes;
-  usage->alloc_overhead_bytes += usage_at_creation_.alloc_overhead_bytes;
-  usage->free_ops += usage_at_creation_.free_ops;
-  usage->free_bytes += usage_at_creation_.free_bytes;
-}
-
-ScopedThreadHeapUsage::ThreadAllocatorUsage
-ScopedThreadHeapUsage::CurrentUsage() {
-  ThreadAllocatorUsage* usage = GetOrCreateThreadUsage();
+  DCHECK_NE(nullptr, usage);
   return *usage;
 }
 
-void ScopedThreadHeapUsage::Initialize() {
-  if (!g_thread_allocator_usage.initialized()) {
-    g_thread_allocator_usage.Initialize([](void* allocator_usage) {
-      delete static_cast<ScopedThreadHeapUsage::ThreadAllocatorUsage*>(
-          allocator_usage);
-    });
-  }
-}
+void HeapUsageTracker::EnableHeapTracking() {
+  EnsureTLSInitialized();
 
-void ScopedThreadHeapUsage::EnableHeapTracking() {
   CHECK_EQ(false, g_heap_tracking_enabled) << "No double-enabling.";
   g_heap_tracking_enabled = true;
 #if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
   base::allocator::InsertAllocatorDispatch(&allocator_dispatch);
 #else
   CHECK(false) << "Can't enable heap tracking without the shim.";
 #endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
 }
 
-void ScopedThreadHeapUsage::DisableHeapTrackingForTesting() {
+bool HeapUsageTracker::IsHeapTrackingEnabled() {
+  return g_heap_tracking_enabled;
+}
+
+void HeapUsageTracker::DisableHeapTrackingForTesting() {
 #if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
   base::allocator::RemoveAllocatorDispatchForTesting(&allocator_dispatch);
 #else
   CHECK(false) << "Can't disable heap tracking without the shim.";
 #endif  // BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
   DCHECK_EQ(true, g_heap_tracking_enabled) << "Heap tracking not enabled.";
   g_heap_tracking_enabled = false;
 }
 
-base::allocator::AllocatorDispatch*
-ScopedThreadHeapUsage::GetDispatchForTesting() {
+void HeapUsageTracker::EnsureTLSInitializedForTesting() {
+  EnsureTLSInitialized();
+}
+
+base::allocator::AllocatorDispatch* HeapUsageTracker::GetDispatchForTesting() {
   return &allocator_dispatch;
 }
 
+void HeapUsageTracker::EnsureTLSInitialized() {
+  if (!g_thread_allocator_usage.initialized()) {
+    g_thread_allocator_usage.Initialize([](void* allocator_usage) {

[fdoray, 2016/10/14 13:03:32]

How can you be sure that this isn't initialized concurrently by multiple
threads?

[Sigurður Ásgeirsson, 2016/10/14 13:23:47]

By contract, EnableHeapTracking can only be called from a single thread, once.

+      delete static_cast<ThreadAllocatorUsage*>(allocator_usage);
+    });
+  }
+}
+
 }  // namespace debug
 }  // namespace base