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

base/allocator/type_profiler.h

Index: base/allocator/type_profiler.h
diff --git a/base/allocator/type_profiler.h b/base/allocator/type_profiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..e76405bcd07d511ed7344a583b64888c3da07d25
--- /dev/null
+++ b/base/allocator/type_profiler.h
@@ -0,0 +1,53 @@
+// 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.
+
+#ifndef BASE_ALLOCATOR_TYPE_PROFILER_H_
+#define BASE_ALLOCATOR_TYPE_PROFILER_H_
+
+#if defined(TYPE_PROFILING)
+
+#include <cstddef>
+#include <typeinfo>
+
+namespace base {
+namespace type_profiler {
+
+typedef void* InterceptFunction(void*, size_t, const std::type_info&);
+
+void* NopIntercept(void* ptr, size_t size, const std::type_info& type);

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

Why isn't this private to type_profiler.cc?  Is it used by a test?

Note that this probably shouldn't be used by external code, as it seems to have
special significance to your implementation.

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

Removed from type_profiler.h, and moved it to anonymous namespace.

+
+class InterceptFunctions {
+ public:
+  // It must be called only once in a process while it is in single-thread.
+  // For now, ContentMainRunnerImpl::Initialize is the only supposed caller
+  // of this function except for single-threaded unit tests.
+  static bool SetFunctions(InterceptFunction* new_intercept,
+                           InterceptFunction* delete_intercept);
+
+ private:
+  friend class TypeProfilerTest;
+
+  // This function is not thread safe.  Use it only when SetInterceptFunctions()
+  // is called in a single-thread such as type_profiler_unittests.
+  static bool IsAvailable();
+};
+
+}  // namespace type_profiler
+}  // namespace base
+
+// These functions wrap all 'new' and 'delete' expressions.
+// They are called by a modified version of Clang checked-in
+// at deps/third_party/llvm-allocated-type.
+
+void* __op_new_intercept__(void* ptr,

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

If these are not called by any code (test code?), they shouldn't be part of a
public interface (and shouldn't be advertised in this header).

Are they called directly from tests?

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

They don't look "called" lexically in source files, but they are actually called
by inserted code at every new/delete expression by our modified Clang compiler. 
(It's the essential point of the compiler extension.)
These prototype declarations are required.

[jar (doing other things), 2012/09/10 16:33:33]

Does the compiler trigger on the *declaration* of these functions, and do
something different? I would have expected it to trigger on the *definition* of
the function, or the compiler flag, to try to call the function.  Header
declarations are generally *only* useful for other code we have.

Even if the *declaration* is the trigger, there seems no reason to put it in in
a header.

Can you point me to documentation that says you must have this declaration in a
header file (which is conceptually unrelated to the source file containing the
definition)?


On 2012/09/07 08:06:45, Dai Mikurube wrote:

[Dai Mikurube (NOT FULLTIME), 2012/09/11 00:57:58]

*Declaration" triggers.  Calling "__op*" is inserted at the compiling phase
naturally, not at the linking phase.  *Definition" is usually in the other
source files.

The modified Clang is designed so that developers should declare these functions
by themselves since :
1) We may be able to declare them automatically if the compiler flag is
specified.  But...
2) These declaration needs another header file (<typeinfo>) before declaration.
3) We found that it makes our Clang modification more complicated to control the
order of "automatically" inserted <typeinfo> and declaration.

It is design decision at the compiler side.  If the modification gets more
complicated, rolling up its base Clang gets difficult.  It easily brings us some
terrible "compiler-side bugs".  We'd like to avoid it.

When we upstream the Clang modification, it would be improved.

There is no public document about that, but I'll add a description at
/deps/third_party/llvm-allocated-type/README.chromium.  What do you think about
this?


On 2012/09/10 16:33:33, jar wrote:

[Dai Mikurube (NOT FULLTIME), 2012/09/11 08:19:28]

Finally, we could modify Clang to declare required prototypes automatically.  It
allowed us to stop including type_profiler.h in all source files by the
"-include" option ("-include" is removed from gyp/gypi).

But, I found that these declarations are still required in type_profiler.h to
make them friends of InterceptFunctions (as you suggested).

To declare "friend ...", prototype declaration is required before "friend ...". 
I added a comment to describe this.

+                           size_t size,
+                           const std::type_info& type);
+
+void* __op_delete_intercept__(void* ptr,
+                              size_t size,
+                              const std::type_info& type);
+
+#endif  // defined(TYPE_PROFILING)
+
+#endif  // BASE_ALLOCATOR_TYPE_PROFILER_H_