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

base/allocator/type_profiler.cc

+// 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 "base/allocator/type_profiler.h"
+
+#if defined(PROFILING_TYPE)
+
+namespace base {
+namespace type_profiler {
+
+static InterceptFunction* g_new_intercept = NULL;
+static InterceptFunction* g_delete_intercept = NULL;
+
+void SetInterceptFunctions(InterceptFunction* new_intercept,
+                           InterceptFunction* delete_intercept) {
+  g_new_intercept = new_intercept;
+  g_delete_intercept = delete_intercept;
+}
+
+bool IsInterceptFunctionsAvailable() {
+  return g_new_intercept != NULL || g_delete_intercept != NULL;

[jar (doing other things), 2012/08/30 16:02:10]

Note that this is not very thread safe, relative to the setting of the intercept
functions.  The values were not atomically set, and on platforms such as ARM,
we're run the risk of getting a corrupted pointer if we depended on this check
to decide if we want to call the intercept.

Can you guarantee that SetInterceptFunctions() was called while we were single
threaded?  At a minimum, there should be a comment in the header that the setter
should ONLY be called while single threaded.

[Dai Mikurube (NOT FULLTIME), 2012/08/31 06:10:30]

Yeah, I know...  In fact, it is not called in the main code, but required only
in type_profiler_unittests.

Added a comment on *THIS* function not to call SetInterceptFunctions() if this
function is used.  What do you think about it?

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

The most common pattern for enforcing this is to have it as a private member of
a class, and have that class friend your tests as needed.  This avoids exposing
it as a public API, and allows you to actually restrict the callers.

On 2012/08/31 06:10:30, Dai Mikurube wrote:

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

Done.

+}
+
+}  // namespace type_profiler
+}  // namespace base
+
+void* __op_new_intercept__(void* ptr,

[jar (doing other things), 2012/08/30 16:02:10]

can we say:

void* ::__op_new_intercept(...) {
...
}

and put that inside your namespace block (between lines 10 and 25?

[Dai Mikurube (NOT FULLTIME), 2012/08/31 06:10:30]

It is impossible.  Clang++ says :

../../base/allocator/type_profiler.cc:25:9: error: definition or redeclaration
of '__op_new_intercept__' cannot name the global
scope../../base/allocator/type_profiler.cc:25:9: error: definition or
redeclaration of '__op_new_intercept__' cannot name the global scope
void* ::__op_new_intercept__(void* ptr,
      ~~^
../../base/allocator/type_profiler.cc:36:9: error: definition or redeclaration
of '__op_delete_intercept__' cannot name the global scope
void* ::__op_delete_intercept__(void* ptr,
      ~~^

You may be correct in terms of c++ standards (I don't know), but we should
submit clang-available code.  We have the linux_clang bot.

fyi, similar error even if we put prototype declarations to the namespace in
type_profiler.h.

+                           size_t size,
+                           const std::type_info& type) {
+  base::type_profiler::InterceptFunction* new_intercept =
+      base::type_profiler::g_new_intercept;
+  if (new_intercept)
+    return new_intercept(ptr, size, type);
+
+  return ptr;
+}
+
+void* __op_delete_intercept__(void* ptr,
+                              size_t size,
+                              const std::type_info& type) {
+  base::type_profiler::InterceptFunction* delete_intercept =
+      base::type_profiler::g_delete_intercept;
+  if (delete_intercept)
+    return delete_intercept(ptr, size, type);
+
+  return ptr;
+}
+
+#endif  // defined(PROFILING_TYPE)