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

base/allocator/type_profiler_unittests.cc

Index: base/allocator/type_profiler_unittests.cc
diff --git a/base/allocator/type_profiler_unittests.cc b/base/allocator/type_profiler_unittests.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4ea25d9ab0d997a8c0b8cc9fd91cd63a26038276
--- /dev/null
+++ b/base/allocator/type_profiler_unittests.cc
@@ -0,0 +1,187 @@
+// 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.
+
+// This is a unittest set for type_profiler.  It is independent from other
+// tests and executed manually like allocator_unittests because type_profiler
+// is not able to turn on/off many times.
+//
+// It tests that the profiler doesn't fail in suspicous cases.  For example,
+// 'new' is not profiled, but 'delete' for the created object is profiled.
+//
+// NOTE: This test must be run with an environment variable "HEAPPROFILE".
+//
+// NOTE: Each test in TypeProfilerTest must be executed separately with using

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

How is this done via the unit test harness?

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

Removed this limitation.

+// --gtest_filter like following :
+//   --gtest_filter="TypeProfilerTest.TestNormalProfiling"
+// because type_profiler provides only an initializer and a stopper for safety.

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

All your code below is single threaded.  As a result, you could call private
methods to reset the state (unset the intercept functions, and clear the map). 
That is a common approach taken in testing, rather than run completely separate
runs of the test harness.

The methods should be private, and labeled for testing only.  Access can be
granted via the standard FRIEND_TEST* macro.

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

Done.

+// It can be initialized once, and stopped once.
+
+#include "base/allocator/type_profiler_control.h"
+#include "base/allocator/type_profiler_tcmalloc.h"
+#include "base/basictypes.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/tcmalloc/chromium/src/gperftools/type_profiler_map.h"
+
+#if defined(TYPE_PROFILING)
+
+namespace base {
+namespace type_profiler {
+
+class TypeProfilerTest : public testing::Test {
+ public:
+  TypeProfilerTest() {}
+
+  void SetUp() {
+    ASSERT_FALSE(isAvailable()) << "this test must be executed separately.";
+  }
+
+ protected:
+  bool isAvailable() {
+    return InterceptFunctions::IsAvailable();
+  }
+
+  static const size_t kDummyArraySize;
+  static const void* const kConstNull;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TypeProfilerTest);
+};
+
+const size_t TypeProfilerTest::kDummyArraySize = 10;
+const void* const TypeProfilerTest::kConstNull = static_cast<const void*>(NULL);
+
+TEST_F(TypeProfilerTest, TestNormalProfiling) {
+  ASSERT_TRUE(InterceptFunctions::SetFunctions(NewInterceptForTCMalloc,
+                                               DeleteInterceptForTCMalloc));
+
+  int* dummy = new int(48);
+  const std::type_info* type;
+
+  type = LookupType(dummy);
+  ASSERT_NE(type, kConstNull);
+  EXPECT_STREQ(type->name(), typeid(int).name());
+  delete dummy;
+
+  type = LookupType(dummy);
+  EXPECT_EQ(type, kConstNull);
+}
+
+TEST_F(TypeProfilerTest, TestNormalArrayProfiling) {
+  ASSERT_TRUE(InterceptFunctions::SetFunctions(NewInterceptForTCMalloc,
+                                               DeleteInterceptForTCMalloc));
+
+  int* dummy = new int[kDummyArraySize];
+  const std::type_info* type;
+
+  type = LookupType(dummy);
+  ASSERT_NE(type, kConstNull);
+  // For an array, the profiler remembers its base type.
+  EXPECT_STREQ(type->name(), typeid(int).name());
+  delete[] dummy;
+
+  type = LookupType(dummy);
+  EXPECT_EQ(type, kConstNull);
+}
+
+TEST_F(TypeProfilerTest, TestRepeatedNewAndDelete) {
+  ASSERT_TRUE(InterceptFunctions::SetFunctions(NewInterceptForTCMalloc,
+                                               DeleteInterceptForTCMalloc));
+
+  int *dummy[kDummyArraySize];
+  const std::type_info* type;
+  for (int i = 0; i < kDummyArraySize; ++i)
+    dummy[i] = new int(i);
+
+  for (int i = 0; i < kDummyArraySize; ++i) {
+    type = LookupType(dummy[i]);
+    ASSERT_NE(type, kConstNull);
+    EXPECT_STREQ(type->name(), typeid(int).name());
+  }
+
+  for (int i = 0; i < kDummyArraySize; ++i) {
+    delete dummy[i];
+    type = LookupType(dummy[i]);
+    ASSERT_EQ(type, kConstNull);
+  }
+}
+
+TEST_F(TypeProfilerTest, TestMultipleNewWithDroppingDelete) {
+  ASSERT_TRUE(InterceptFunctions::SetFunctions(NewInterceptForTCMalloc,
+                                               DeleteInterceptForTCMalloc));
+
+  static const size_t large_size = 256 * 1024;
+
+  char* dummy_char = new char[large_size];
+  const std::type_info* type;
+
+  type = LookupType(dummy_char);
+  ASSERT_NE(type, kConstNull);
+  EXPECT_STREQ(type->name(), typeid(char).name());
+
+  // Call "::operator delete" directly to drop __op_delete_intercept__.
+  ::operator delete(dummy_char);

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

Is it not well defined to new up an array, and call operator delete on the
resulting pointer.

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

Thanks for the good catch.  I overlooked it when I changed the implementation of
this test a few times (e.g. array <=> non-array).

Fixed to call "::operator delete[]".

+
+  type = LookupType(dummy_char);
+  ASSERT_NE(type, kConstNull);
+  EXPECT_STREQ(type->name(), typeid(char).name());
+
+  // Allocates a little different size.
+  int* dummy_int = new int[large_size / sizeof(int) - 1];

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

nit: sizeof(*dummy_int)


For clarity, you might also have the same pattern on line 115

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

Done.

+
+  // We expect that tcmalloc returns the same address for these large (over 32k)
+  // allocation calls.  It usually happens, but maybe probablistic.
+  ASSERT_EQ(static_cast<void*>(dummy_int), static_cast<void*>(dummy_char)) <<
+      "two new (malloc) calls didn't return the same address; retry it.";
+
+  type = LookupType(dummy_int);
+  ASSERT_NE(type, kConstNull);
+  EXPECT_STREQ(type->name(), typeid(int).name());
+
+  delete dummy_int;

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

delete[] dummy_int;

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

Done.

+
+  type = LookupType(dummy_int);
+  EXPECT_EQ(type, kConstNull);
+}
+
+TEST_F(TypeProfilerTest, TestProfileDeleteWithoutProfiledNew) {
+  int* dummy = new int(48);
+  const std::type_info* type;
+
+  // Set intercept functions after 'dummy' is new'ed.
+  ASSERT_TRUE(InterceptFunctions::SetFunctions(NewInterceptForTCMalloc,
+                                               DeleteInterceptForTCMalloc));
+
+  delete dummy;
+
+  type = LookupType(dummy);
+  EXPECT_EQ(type, kConstNull);
+}
+
+TEST_F(TypeProfilerTest, TestProfileNewWithoutProfiledDelete) {
+  ASSERT_TRUE(InterceptFunctions::SetFunctions(NewInterceptForTCMalloc,
+                                               DeleteInterceptForTCMalloc));
+
+  int* dummy = new int(48);
+  const std::type_info* type;
+
+  StopProfiling();
+
+  delete dummy;
+
+  // NOTE: We accept that a profile entry remains when a profiled object is
+  // deleted after StopProfiling().
+  type = LookupType(dummy);
+  ASSERT_NE(type, kConstNull);
+  EXPECT_STREQ(type->name(), typeid(int).name());
+}
+
+}  // namespace type_profiler
+}  // namespace base
+
+#endif  // defined(TYPE_PROFILING)
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}