Added page to Observatory to display native memory allocation information.

runtime/vm/malloc_hooks.cc

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 
 #if defined(DART_USE_TCMALLOC) && !defined(PRODUCT) &&                         \
     !defined(TARGET_ARCH_DBC) && !defined(TARGET_OS_FUCHSIA)
 
 #include "vm/malloc_hooks.h"
@@ skipping 113 matching lines @@
   Mutex* mutex_;
   ThreadId* owner_;
 };
 
 // AllocationInfo contains all information related to a given allocation
 // including:
 //   -Allocation size in bytes
 //   -Stack trace corresponding to the location of allocation, if applicable
 class AllocationInfo {
  public:
-  explicit AllocationInfo(intptr_t allocation_size)
-      : sample_(NULL), allocation_size_(allocation_size) {
+  explicit AllocationInfo(uword address, intptr_t allocation_size)

[zra, 2017/03/16 20:36:37]

Don't need 'explicit' when there is more than one argument.

[bkonyi, 2017/03/21 01:53:23]

Done.

+      : sample_(NULL), address_(address), allocation_size_(allocation_size) {
     // Stack trace collection is disabled when we are in the process of creating
     // the first OSThread in order to prevent deadlocks.
     if (MallocHooksState::ProfilingEnabled() &&
         MallocHooksState::stack_trace_collection_enabled()) {
-      sample_ = Profiler::SampleNativeAllocation(kSkipCount);
+      sample_ = Profiler::SampleNativeAllocation(kSkipCount, address,
+                                                 allocation_size);
+      ASSERT(sample_->native_allocation_address() == address_);
     }
   }
 
+  ~AllocationInfo() {
+    if (sample_ == NULL) {
+      return;
+    }
+    uword allocation_address = sample_->native_allocation_address();
+    if (allocation_address != address_) {

[zra, 2017/03/16 20:36:37]

Why might this happen?

[bkonyi, 2017/03/16 20:48:40]

The samples are stored in a ring buffer and are eventually overwritten with new
samples. This is just to check if the sample has already been overwritten before
trying to mark it as a freed native allocation sample. Now that I think about it
this might be racy...

[bkonyi, 2017/03/21 01:53:23]

I've changed how this is done so that we should be able to avoid races.

+      return;
+    }
+    sample_->set_native_allocation_address(0);

[Cutch, 2017/03/16 20:38:16]

what about the size too?

[bkonyi, 2017/03/21 01:53:23]

I've changed how I check if a native allocation sample has been freed or not to
avoid races.

+  }
+
   Sample* sample() const { return sample_; }
   intptr_t allocation_size() const { return allocation_size_; }
 
  private:
   Sample* sample_;

[zra, 2017/03/16 20:36:37]

It might be worthwhile to make an explicit note here that the AllocationInfo
doesn't own the Sample object.

[bkonyi, 2017/03/21 01:53:23]

Done.

+  uword address_;
   intptr_t allocation_size_;
 
   // The number of frames that are generated by the malloc hooks and collection
   // of the stack trace. These frames are ignored when collecting the stack
   // trace for a memory allocation. If this number is incorrect, some tests in
   // malloc_hook_tests.cc might fail, particularily
   // StackTraceMallocHookLengthTest. If this value is updated, please make sure
   // that the MallocHooks test cases pass on all platforms.
-  static const intptr_t kSkipCount = 5;
+  static const intptr_t kSkipCount = 6;
 };
 
 
 // Custom key/value trait specifically for address/size pairs. Unlike
 // RawPointerKeyValueTrait, the default value is -1 as 0 can be a valid entry.
 class AddressKeyValueTrait : public AllStatic {
  public:
   typedef const void* Key;
   typedef AllocationInfo* Value;
 
@@ skipping 241 matching lines @@
   if (MallocHooksState::IsLockHeldByCurrentThread() ||
       !MallocHooksState::IsOriginalProcess()) {
     return;
   }
 
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
   // Now that we hold the lock, check to make sure everything is still active.
   if ((ptr != NULL) && MallocHooksState::Active()) {
     MallocHooksState::IncrementHeapAllocatedMemoryInBytes(size);
-    MallocHooksState::address_map()->Insert(ptr, new AllocationInfo(size));
+    MallocHooksState::address_map()->Insert(
+        ptr, new AllocationInfo(reinterpret_cast<uword>(ptr), size));
   }
 }
 
 
 void MallocHooksState::RecordFreeHook(const void* ptr) {
   if (MallocHooksState::IsLockHeldByCurrentThread() ||
       !MallocHooksState::IsOriginalProcess()) {
     return;
   }
 
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
   // Now that we hold the lock, check to make sure everything is still active.
   if ((ptr != NULL) && MallocHooksState::Active()) {
     AllocationInfo* allocation_info = NULL;
     if (MallocHooksState::address_map()->Lookup(ptr, &allocation_info)) {
       MallocHooksState::DecrementHeapAllocatedMemoryInBytes(
           allocation_info->allocation_size());
       MallocHooksState::address_map()->Remove(ptr);
       delete allocation_info;
     }
   }
 }
 
 }  // namespace dart
 
 #endif  // defined(DART_USE_TCMALLOC) && !defined(PRODUCT) &&
         // !defined(TARGET_ARCH_DBC) && !defined(TARGET_OS_FUCHSIA)