Type profiler by intercepting 'new' and 'delete' expressions.

third_party/tcmalloc/chromium/src/type_profiler_map.cc

Index: third_party/tcmalloc/chromium/src/type_profiler_map.cc
diff --git a/third_party/tcmalloc/chromium/src/type_profiler_map.cc b/third_party/tcmalloc/chromium/src/type_profiler_map.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0b4bc70cf9636e2b34c35119e51b2d1e19e1eccd
--- /dev/null
+++ b/third_party/tcmalloc/chromium/src/type_profiler_map.cc
@@ -0,0 +1,109 @@
+// Copyright 2012 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 <config.h>
+
+#include <new>
+#include <typeinfo>
+
+#include <gperftools/type_profiler_map.h>
+
+#include "addressmap-inl.h"
+#include "base/logging.h"
+#include "base/low_level_alloc.h"
+#include "base/spinlock.h"
+#include "tcmalloc_guard.h"
+
+static const TCMallocGuard tcmalloc_initializer;
+
+//----------------------------------------------------------------------
+// A struct to store size and type_info of an object
+//----------------------------------------------------------------------
+
+struct ObjectInfo {

[jar (doing other things), 2012/09/02 01:37:11]

Please surround this in an anonymous namespace, including all the local
structures, and what you have as static data and methods.  As it currently
stands, ObjectInfo has global linkage appearing at global scope, and can
interfere with other code all across Chrome.

Best practice is to use an anonymous namespace for all the local stuff (and I
don't mind seeing the "static" keyword as well... but that is personal
preference, since it then has no impact on linkage once you're in an anonymous
namespace.).

The nice pattern here should be:

// No code above this point typically (but some folks put
// statics here.)
namespace Whatever_namespace_most_code_lives_in {
namespace {
// All your global static stuff (can reference
// Whatever_namespace_most_code_lives_in stuff).
}  // anonymous
// All your real code for this CC file with external linkage.
} // Whatever_namespace_most_code_lives_in 

[Dai Mikurube (NOT FULLTIME), 2012/09/03 08:16:30]

Done.

[jar (doing other things), 2012/09/06 19:31:43]

Please use best practice, which is anonymous namespace, per previous review
comment.

I had previously said that the anonymous namespace was needed, and that static
keyword was optional.  I asked around, and since global static is deprecated in
C++, contrary to my previous comment about "optional," the "static" keyword
should be removed once you use the required anonymous namespace.


On 2012/09/03 08:16:30, Dai Mikurube wrote:

[Dai Mikurube (NOT FULLTIME), 2012/09/07 08:06:45]

Removed "static"s.

+ public:
+  ObjectInfo(): size(0), type(NULL) {}
+  ObjectInfo(unsigned int size_arg, const std::type_info* type_arg)
+      : size(size_arg),
+        type(type_arg) {
+  }
+
+  unsigned int size;
+  const std::type_info* type;
+};
+
+//----------------------------------------------------------------------
+// Locking
+//----------------------------------------------------------------------
+
+static SpinLock g_type_profiler_lock(SpinLock::LINKER_INITIALIZED);
+
+//----------------------------------------------------------------------
+// Simple allocator for type_info map's internal memory
+//----------------------------------------------------------------------
+
+static LowLevelAlloc::Arena* g_type_profiler_map_memory = NULL;
+
+static void* TypeProfilerMalloc(size_t bytes) {
+  return LowLevelAlloc::AllocWithArena(bytes, g_type_profiler_map_memory);
+}
+
+static void TypeProfilerFree(void* p) {
+  LowLevelAlloc::Free(p);
+}
+
+//----------------------------------------------------------------------
+// Profiling control/state data
+//----------------------------------------------------------------------
+
+static AddressMap<ObjectInfo>* g_type_profiler_map = NULL;
+
+//----------------------------------------------------------------------
+// Manage type_info map
+//----------------------------------------------------------------------
+
+static void InitializeTypeProfilerMemory() {
+  if (g_type_profiler_map_memory != NULL) {
+    RAW_DCHECK(g_type_profiler_map != NULL, "TypeProfilerMap is NULL");
+    return;
+  }
+
+  g_type_profiler_map_memory =
+      LowLevelAlloc::NewArena(0, LowLevelAlloc::DefaultArena());
+
+  g_type_profiler_map =
+      new(TypeProfilerMalloc(sizeof(*g_type_profiler_map)))
+          AddressMap<ObjectInfo>(TypeProfilerMalloc, TypeProfilerFree);
+}
+
+namespace base {
+namespace type_profiler {
+
+void InsertType(void* address, unsigned int size, const std::type_info& type) {
+  SpinLockHolder lock(&g_type_profiler_lock);
+  InitializeTypeProfilerMemory();
+
+  g_type_profiler_map->Insert(address, ObjectInfo(size, &type));
+}
+
+void EraseType(void* address) {
+  SpinLockHolder lock(&g_type_profiler_lock);
+  InitializeTypeProfilerMemory();
+
+  ObjectInfo obj;
+  g_type_profiler_map->FindAndRemove(address, &obj);
+}
+
+const std::type_info* LookupType(const void* address) {
+  SpinLockHolder lock(&g_type_profiler_lock);
+  InitializeTypeProfilerMemory();
+
+  const ObjectInfo* found = g_type_profiler_map->Find(address);
+  if (found == NULL)
+    return NULL;
+  return found->type;
+}
+
+}  // namespace type_profiler
+}  // namespace base