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

base/allocator/allocator_shim.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_ALLOCATOR_ALLOCATOR_SHIM_H_
 #define BASE_ALLOCATOR_ALLOCATOR_SHIM_H_
 
 #include <stddef.h>
 
 #include "base/base_export.h"
@@ skipping 38 matching lines @@
   using AllocZeroInitializedFn = void*(const AllocatorDispatch* self,
                                        size_t n,
                                        size_t size);
   using AllocAlignedFn = void*(const AllocatorDispatch* self,
                                size_t alignment,
                                size_t size);
   using ReallocFn = void*(const AllocatorDispatch* self,
                           void* address,
                           size_t size);
   using FreeFn = void(const AllocatorDispatch* self, void* address);
+  // Returns the best available estimate for the actual amount of memory
+  // consumed by the allocation |address|. If possible, this should include
+  // heap overhead or at least a decent estimate of the full cost of the
+  // allocation.
+  using GetSizeEstimateFn = size_t(const AllocatorDispatch* self,

[Primiano Tucci (use gerrit), 2016/08/24 14:11:46]

I don't think that this function should be part of the shim chain. If I read the
code correctly, your intent here is not to "intercept" the GetSizeEstimate
function, you just want to provide one implementation for each OS.

I think the cleanest approach is adding a function to allocator_extensions.h,
and in the .cc file have something like
#if OS_LINUX && OS_ANDROID
 return malloc_usable_size(...)
#elif OS_WINDOWS
 whatever incantation
etc 

If you think to that, the GetEstimateSize function doesn't really depend on the
shim, you are just leveraging it here because that happens to convenientely have
the various if(OS/allocator).

[Primiano Tucci (use gerrit), 2016/08/24 15:28:46]

siggi@ and I had a chat offline. siggi@ explained me that in the near future
there is the desire to use the shim to provide some kind of
statistically-alternate-heap. In that view, makes sense for the GetSizeEstimate
function to be shimmed, as that implementation will become dependent on the
presence of the "alternate heap" shim layers.

[Sigurður Ásgeirsson, 2016/09/01 15:18:17]

Yeah - it would be nice to fully abstract the notion of a heap with the shim,
perhaps to the point of e.g. getting the aggregate memory usage for tracing
through the shim.

[Sigurður Ásgeirsson, 2016/09/01 15:18:17]

Acknowledged.

+                                   void* address);
 
   AllocFn* const alloc_function;
   AllocZeroInitializedFn* const alloc_zero_initialized_function;
   AllocAlignedFn* const alloc_aligned_function;
   ReallocFn* const realloc_function;
   FreeFn* const free_function;
+  GetSizeEstimateFn* const get_size_estimate_function;
 
   const AllocatorDispatch* next;
 
   // |default_dispatch| is statically defined by one (and only one) of the
   // allocator_shim_default_dispatch_to_*.cc files, depending on the build
   // configuration.
   static const AllocatorDispatch default_dispatch;
 };
 
 // When true makes malloc behave like new, w.r.t calling the new_handler if
@@ skipping 12 matching lines @@
 
 // Test-only. Rationale: (1) lack of use cases; (2) dealing safely with a
 // removal of arbitrary elements from a singly linked list would require a lock
 // in malloc(), which we really don't want.
 BASE_EXPORT void RemoveAllocatorDispatchForTesting(AllocatorDispatch* dispatch);
 
 }  // namespace allocator
 }  // namespace base
 
 #endif  // BASE_ALLOCATOR_ALLOCATOR_SHIM_H_