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

base/allocator/allocator_shim_default_dispatch_to_glibc.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/allocator/allocator_shim.h"
 
 // This translation unit defines a default dispatch for the allocator shim which
 // routes allocations to libc functions.
 // The code here is strongly inspired from tcmalloc's libc_override_glibc.h.
 
 extern "C" {
 void* __libc_malloc(size_t size);
 void* __libc_calloc(size_t n, size_t size);
 void* __libc_realloc(void* address, size_t size);
 void* __libc_memalign(size_t alignment, size_t size);
 void __libc_free(void* ptr);
+size_t __malloc_usable_size(void* ptr);

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

not sure you ned this fwd declaration

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

Done.

 }  // extern "C"
 
 namespace {
 
 using base::allocator::AllocatorDispatch;
 
 void* GlibcMalloc(const AllocatorDispatch*, size_t size) {
   return __libc_malloc(size);
 }
 
 void* GlibcCalloc(const AllocatorDispatch*, size_t n, size_t size) {
   return __libc_calloc(n, size);
 }
 
 void* GlibcRealloc(const AllocatorDispatch*, void* address, size_t size) {
   return __libc_realloc(address, size);
 }
 
 void* GlibcMemalign(const AllocatorDispatch*, size_t alignment, size_t size) {
   return __libc_memalign(alignment, size);
 }
 
 void GlibcFree(const AllocatorDispatch*, void* address) {
   __libc_free(address);
 }
+}
+void GlibcFree(const AllocatorDispatch*, void* address) {

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

seems like you accidentally copy/pasted this twice.

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

Ooops, I wonder how this even compiled. Fixed :/.

+  __libc_free(address);
+}
+
+size_t GlibcGetSizeEstimate(const AllocatorDispatch*, void* address) {
+  return __libc_usable_size(address);

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

I don't think you need to go down into __libc internals (Also IIRC there is a
Linux release bot that has a whitelist of dependent symbols and will complain if
you try to add a new dependency).
I think that both for Linux (tcmalloc or glibc) and Android, here you simply
want to do :

return malloc_usable_size(address)

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

I think you mean __malloc_usable_size here.

The natural question that comes here is: should we also wrap and hook calls to
malloc_usable_size and route them to this function ?
That would guarantee that  if code inside of chrome calls that, they get trapped
by the shim and we can provide our own implementation.
Not sure how much we care about that. I think the realistic use case here is: if
in the near future we provide an alternative heap implementation and chromium
code calls malloc_usable_size, will it crash if we ask
malloc_usable_some(some_Address_that_was_intercepted_by_the_shim?)
Maybe we should do that, in a later CL, for consistency and to cover ourself
from this case.

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

Thanks, added a TODO.

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

Done.

+}
 
 }  // namespace
 
 const AllocatorDispatch AllocatorDispatch::default_dispatch = {
-    &GlibcMalloc,   /* alloc_function */
-    &GlibcCalloc,   /* alloc_zero_initialized_function */
-    &GlibcMemalign, /* alloc_aligned_function */
-    &GlibcRealloc,  /* realloc_function */
-    &GlibcFree,     /* free_function */
-    nullptr,        /* next */
+    &GlibcMalloc,          /* alloc_function */
+    &GlibcCalloc,          /* alloc_zero_initialized_function */
+    &GlibcMemalign,        /* alloc_aligned_function */
+    &GlibcRealloc,         /* realloc_function */
+    &GlibcFree,            /* free_function */
+    &GlibcGetSizeEstimate, /* get_size_estimate_function */
+    nullptr,               /* next */
 };