Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(3469)

Unified Diff: base/allocator/type_profiler_unittests.cc

Issue 10411047: Type profiler by intercepting 'new' and 'delete' expressions. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: reflected the comments. Created 8 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
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..2e93388d1887d40e7cd8f9c70e28ae580a5c10d8
--- /dev/null
+++ b/base/allocator/type_profiler_unittests.cc
@@ -0,0 +1,183 @@
+// 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
+// --gtest_filter like following :
+// --gtest_filter="TypeProfilerTest.NormalProfiling"
+// because type_profiler provides only an initializer and a stopper for safety.
+// It can be initialized once, and stopped once.
+
+#include "base/allocator/type_profiler_control.h"
+#include "base/allocator/type_profiler_tcmalloc.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/tcmalloc/chromium/src/gperftools/type_profiler_map.h"
+
+#include <iostream>
jar (doing other things) 2012/09/02 01:37:11 nit: include order
Dai Mikurube (NOT FULLTIME) 2012/09/03 08:16:30 Removed it. (I overlooked.)
+
+#if defined(TYPE_PROFILING)
+static const size_t g_dummy_array_size = 10;
+static const void* const g_const_null = static_cast<const void*>(NULL);
+
+TEST(TypeProfilerTest, NormalProfiling) {
+ ASSERT_FALSE(base::type_profiler::IsInterceptFunctionsAvailable()) <<
+ "this test must be executed separately.";
+
+ base::type_profiler::SetInterceptFunctions(
jar (doing other things) 2012/09/02 01:37:11 Please put this entire test suite into the base::t
Dai Mikurube (NOT FULLTIME) 2012/09/03 08:16:30 Done.
+ base::type_profiler::NewInterceptForTCMalloc,
+ base::type_profiler::DeleteInterceptForTCMalloc);
+
+ int* dummy = new int(48);
+ const std::type_info* type;
+
+ type = base::type_profiler::LookupType(dummy);
+ ASSERT_NE(type, g_const_null);
+ EXPECT_STREQ(type->name(), typeid(int).name());
+ delete dummy;
+
+ type = base::type_profiler::LookupType(dummy);
+ EXPECT_EQ(type, g_const_null);
+}
+
+TEST(TypeProfilerTest, NormalArrayProfiling) {
+ ASSERT_FALSE(base::type_profiler::IsInterceptFunctionsAvailable()) <<
+ "this test must be executed separately.";
+
+ base::type_profiler::SetInterceptFunctions(
+ base::type_profiler::NewInterceptForTCMalloc,
+ base::type_profiler::DeleteInterceptForTCMalloc);
+
+ int* dummy = new int[g_dummy_array_size];
+ const std::type_info* type;
+
+ type = base::type_profiler::LookupType(dummy);
+ ASSERT_NE(type, g_const_null);
+ // For an array, the profiler remembers its base type.
+ EXPECT_STREQ(type->name(), typeid(int).name());
+ delete[] dummy;
+
+ type = base::type_profiler::LookupType(dummy);
+ EXPECT_EQ(type, g_const_null);
+}
+
+TEST(TypeProfilerTest, RepeatedNewAndDelete) {
+ ASSERT_FALSE(base::type_profiler::IsInterceptFunctionsAvailable()) <<
+ "this test must be executed separately.";
+
+ base::type_profiler::SetInterceptFunctions(
+ base::type_profiler::NewInterceptForTCMalloc,
+ base::type_profiler::DeleteInterceptForTCMalloc);
+
+ int *dummy[g_dummy_array_size];
+ const std::type_info* type;
+ for (int i = 0; i < g_dummy_array_size; ++i)
+ dummy[i] = new int(i);
+
+ for (int i = 0; i < g_dummy_array_size; ++i) {
+ type = base::type_profiler::LookupType(dummy[i]);
+ ASSERT_NE(type, g_const_null);
+ EXPECT_STREQ(type->name(), typeid(int).name());
+ }
+
+ for (int i = 0; i < g_dummy_array_size; ++i) {
+ delete dummy[i];
+ type = base::type_profiler::LookupType(dummy[i]);
+ ASSERT_EQ(type, g_const_null);
+ }
+}
+
+TEST(TypeProfilerTest, MultipleNewWithDroppingDelete) {
+ ASSERT_FALSE(base::type_profiler::IsInterceptFunctionsAvailable()) <<
+ "this test must be executed separately.";
+
+ static const size_t large_size = 256 * 1024;
+
+ base::type_profiler::SetInterceptFunctions(
+ base::type_profiler::NewInterceptForTCMalloc,
+ base::type_profiler::DeleteInterceptForTCMalloc);
+
+ char* dummy_char = new char[large_size];
+ const std::type_info* type;
+
+ type = base::type_profiler::LookupType(dummy_char);
+ ASSERT_NE(type, g_const_null);
+ EXPECT_STREQ(type->name(), typeid(char).name());
+
+ // Call ::operator delete directly to drop __op_delete_intercept__.
+ ::operator delete(dummy_char);
+
+ type = base::type_profiler::LookupType(dummy_char);
+ ASSERT_NE(type, g_const_null);
+ EXPECT_STREQ(type->name(), typeid(char).name());
+
+ // Allocates a little different size.
+ int* dummy_int = new int[large_size / sizeof(int) - 1];
+
+ // 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 = base::type_profiler::LookupType(dummy_int);
+ ASSERT_NE(type, g_const_null);
+ EXPECT_STREQ(type->name(), typeid(int).name());
+
+ delete dummy_int;
+
+ type = base::type_profiler::LookupType(dummy_int);
+ EXPECT_EQ(type, g_const_null);
+}
+
+TEST(TypeProfilerTest, ProfileDeleteWithoutProfiledNew) {
+ ASSERT_FALSE(base::type_profiler::IsInterceptFunctionsAvailable()) <<
+ "this test must be executed separately.";
+
+ int* dummy = new int(48);
+ const std::type_info* type;
+
+ base::type_profiler::SetInterceptFunctions(
+ base::type_profiler::NewInterceptForTCMalloc,
+ base::type_profiler::DeleteInterceptForTCMalloc);
+
+ delete dummy;
+
+ type = base::type_profiler::LookupType(dummy);
+ EXPECT_EQ(type, g_const_null);
+}
+
+TEST(TypeProfilerTest, ProfileNewWithoutProfiledDelete) {
+ ASSERT_FALSE(base::type_profiler::IsInterceptFunctionsAvailable()) <<
+ "this test must be executed separately.";
+
+ base::type_profiler::SetInterceptFunctions(
+ base::type_profiler::NewInterceptForTCMalloc,
+ base::type_profiler::DeleteInterceptForTCMalloc);
+
+ int* dummy = new int(48);
+ const std::type_info* type;
+
+ base::type_profiler::StopProfiling();
+
+ delete dummy;
+
+ // NOTE: We accept that a profile entry remains when a profiled object is
+ // deleted after StopProfiling().
+ type = base::type_profiler::LookupType(dummy);
+ ASSERT_NE(type, g_const_null);
+ EXPECT_STREQ(type->name(), typeid(int).name());
+}
+#endif // defined(TYPE_PROFILING)
+
+int main(int argc, char** argv) {
+ testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}

Powered by Google App Engine
This is Rietveld 408576698