Disabled MallocHooks code in Release due to performance concerns. Added enable_malloc_hooks flag to…

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)
 
 #include "vm/malloc_hooks.h"
 
@@ skipping 185 matching lines @@
 intptr_t MallocHooksState::original_pid_ = MallocHooksState::kInvalidPid;
 Mutex* MallocHooksState::malloc_hook_mutex_ = new Mutex();
 
 // Memory allocation state information.
 intptr_t MallocHooksState::allocation_count_ = 0;
 intptr_t MallocHooksState::heap_allocated_memory_in_bytes_ = 0;
 AddressMap* MallocHooksState::address_map_ = NULL;
 
 
 void MallocHooks::InitOnce() {
-  MutexLocker ml(MallocHooksState::malloc_hook_mutex());
-  ASSERT(!MallocHooksState::Active());
+  if (FLAG_enable_malloc_hooks) {

[zra, 2017/02/17 23:43:27]

if (!FLAG_enable_malloc_hooks) {
  return;
}

[bkonyi, 2017/02/18 00:01:11]

Done.

+    MutexLocker ml(MallocHooksState::malloc_hook_mutex());
+    ASSERT(!MallocHooksState::Active());
 
-  MallocHookScope::InitMallocHookFlag();
-  MallocHooksState::Init();
+    MallocHookScope::InitMallocHookFlag();
+    MallocHooksState::Init();
 
-  // Register malloc hooks.
-  bool success = false;
-  success = MallocHook::AddNewHook(&MallocHooksState::RecordAllocHook);
-  ASSERT(success);
-  success = MallocHook::AddDeleteHook(&MallocHooksState::RecordFreeHook);
-  ASSERT(success);
+    // Register malloc hooks.
+    bool success = false;
+    success = MallocHook::AddNewHook(&MallocHooksState::RecordAllocHook);
+    ASSERT(success);
+    success = MallocHook::AddDeleteHook(&MallocHooksState::RecordFreeHook);
+    ASSERT(success);
+  }
 }
 
 
 void MallocHooks::TearDown() {
-  MutexLocker ml(MallocHooksState::malloc_hook_mutex());
-  ASSERT(MallocHooksState::Active());
+  if (FLAG_enable_malloc_hooks) {

[zra, 2017/02/17 23:43:27]

ditto

[bkonyi, 2017/02/18 00:01:11]

Done.

+    MutexLocker ml(MallocHooksState::malloc_hook_mutex());
+    ASSERT(MallocHooksState::Active());
 
-  // Remove malloc hooks.
-  bool success = false;
-  success = MallocHook::RemoveNewHook(&MallocHooksState::RecordAllocHook);
-  ASSERT(success);
-  success = MallocHook::RemoveDeleteHook(&MallocHooksState::RecordFreeHook);
-  ASSERT(success);
+    // Remove malloc hooks.
+    bool success = false;
+    success = MallocHook::RemoveNewHook(&MallocHooksState::RecordAllocHook);
+    ASSERT(success);
+    success = MallocHook::RemoveDeleteHook(&MallocHooksState::RecordFreeHook);
+    ASSERT(success);
 
-  MallocHooksState::TearDown();
-  MallocHookScope::DestroyMallocHookFlag();
+    MallocHooksState::TearDown();
+    MallocHookScope::DestroyMallocHookFlag();
+  }
 }
 
 
 void MallocHooks::ResetStats() {
-  MutexLocker ml(MallocHooksState::malloc_hook_mutex());
-  if (MallocHooksState::Active()) {
-    MallocHooksState::ResetStats();
+  if (FLAG_enable_malloc_hooks) {

[zra, 2017/02/17 23:43:27]

ditto

[bkonyi, 2017/02/18 00:01:11]

Done.

+    MutexLocker ml(MallocHooksState::malloc_hook_mutex());
+    if (MallocHooksState::Active()) {
+      MallocHooksState::ResetStats();
+    }
   }
 }
 
 
 bool MallocHooks::Active() {
+  if (!FLAG_enable_malloc_hooks) {
+    return false;
+  }
   ASSERT(MallocHooksState::malloc_hook_mutex()->IsOwnedByCurrentThread());
   return MallocHooksState::Active();
 }
 
 
 void MallocHooks::PrintToJSONObject(JSONObject* jsobj) {
+  if (!FLAG_enable_malloc_hooks) {
+    return;
+  }
   intptr_t allocated_memory = 0;
   intptr_t allocation_count = 0;
   bool add_usage = false;
   // AddProperty may call malloc which would result in an attempt
   // to acquire the lock recursively so we extract the values first
   // and then add the JSON properties.
   {
     MutexLocker ml(MallocHooksState::malloc_hook_mutex());
     if (Active()) {
       allocated_memory = MallocHooksState::heap_allocated_memory_in_bytes();
       allocation_count = MallocHooksState::allocation_count();
       add_usage = true;
     }
   }
   if (add_usage) {
     jsobj->AddProperty("_heapAllocatedMemoryUsage", allocated_memory);
     jsobj->AddProperty("_heapAllocationCount", allocation_count);
   }
 }
 
 
 intptr_t MallocHooks::allocation_count() {
+  if (!FLAG_enable_malloc_hooks) {
+    return 0;
+  }
   MutexLocker ml(MallocHooksState::malloc_hook_mutex());
   return MallocHooksState::allocation_count();
 }
 
 
 intptr_t MallocHooks::heap_allocated_memory_in_bytes() {
+  if (!FLAG_enable_malloc_hooks) {
+    return 0;
+  }
   MutexLocker ml(MallocHooksState::malloc_hook_mutex());
   return MallocHooksState::heap_allocated_memory_in_bytes();
 }
 
 
 void MallocHooksState::RecordAllocHook(const void* ptr, size_t size) {
   if (MallocHookScope::IsInHook() || !MallocHooksState::IsOriginalProcess()) {
     return;
   }
 
@@ skipping 24 matching lines @@
     if (MallocHooksState::address_map()->Lookup(ptr, &size)) {
       MallocHooksState::DecrementHeapAllocatedMemoryInBytes(size);
       MallocHooksState::address_map()->Remove(ptr);
     }
   }
 }
 
 }  // namespace dart
 
 #endif  // defined(DART_USE_TCMALLOC) && !defined(PRODUCT)