| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/trace_event/heap_profiler_heap_dump_writer.h" | |
| 6 | |
| 7 #include <stddef.h> | |
| 8 | |
| 9 #include <memory> | |
| 10 #include <set> | |
| 11 #include <string> | |
| 12 | |
| 13 #include "base/json/json_reader.h" | |
| 14 #include "base/macros.h" | |
| 15 #include "base/memory/ptr_util.h" | |
| 16 #include "base/trace_event/heap_profiler_allocation_context.h" | |
| 17 #include "base/trace_event/heap_profiler_stack_frame_deduplicator.h" | |
| 18 #include "base/trace_event/heap_profiler_type_name_deduplicator.h" | |
| 19 #include "base/trace_event/memory_dump_session_state.h" | |
| 20 #include "base/trace_event/trace_event_argument.h" | |
| 21 #include "base/values.h" | |
| 22 #include "testing/gtest/include/gtest/gtest.h" | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 using base::trace_event::StackFrame; | |
| 27 | |
| 28 // Define all strings once, because the deduplicator requires pointer equality, | |
| 29 // and string interning is unreliable. | |
| 30 StackFrame kBrowserMain = StackFrame::FromTraceEventName("BrowserMain"); | |
| 31 StackFrame kRendererMain = StackFrame::FromTraceEventName("RendererMain"); | |
| 32 StackFrame kCreateWidget = StackFrame::FromTraceEventName("CreateWidget"); | |
| 33 StackFrame kInitialize = StackFrame::FromTraceEventName("Initialize"); | |
| 34 StackFrame kGetBitmap = StackFrame::FromTraceEventName("GetBitmap"); | |
| 35 | |
| 36 const char kInt[] = "int"; | |
| 37 const char kBool[] = "bool"; | |
| 38 const char kString[] = "string"; | |
| 39 | |
| 40 } // namespace | |
| 41 | |
| 42 namespace base { | |
| 43 namespace trace_event { | |
| 44 namespace internal { | |
| 45 | |
| 46 std::unique_ptr<const Value> WriteAndReadBack(const std::set<Entry>& entries) { | |
| 47 std::unique_ptr<TracedValue> traced_value = Serialize(entries); | |
| 48 std::string json; | |
| 49 traced_value->AppendAsTraceFormat(&json); | |
| 50 return JSONReader::Read(json); | |
| 51 } | |
| 52 | |
| 53 std::unique_ptr<const DictionaryValue> WriteAndReadBackEntry(Entry entry) { | |
| 54 std::set<Entry> input_entries; | |
| 55 input_entries.insert(entry); | |
| 56 | |
| 57 std::unique_ptr<const Value> json_dict = WriteAndReadBack(input_entries); | |
| 58 | |
| 59 // Note: Ideally these should use |ASSERT_TRUE| instead of |EXPECT_TRUE|, but | |
| 60 // |ASSERT_TRUE| can only be used in void functions. | |
| 61 const DictionaryValue* dictionary; | |
| 62 EXPECT_TRUE(json_dict->GetAsDictionary(&dictionary)); | |
| 63 | |
| 64 const ListValue* json_entries; | |
| 65 EXPECT_TRUE(dictionary->GetList("entries", &json_entries)); | |
| 66 | |
| 67 const DictionaryValue* json_entry; | |
| 68 EXPECT_TRUE(json_entries->GetDictionary(0, &json_entry)); | |
| 69 | |
| 70 return json_entry->CreateDeepCopy(); | |
| 71 } | |
| 72 | |
| 73 // Given a desired stack frame ID and type ID, looks up the entry in the set and | |
| 74 // asserts that it is present and has the expected size and count. | |
| 75 void AssertSizeAndCountEq(const std::set<Entry>& entries, | |
| 76 int stack_frame_id, | |
| 77 int type_id, | |
| 78 const AllocationMetrics& expected) { | |
| 79 // The comparison operator for |Entry| does not take size into account, so by | |
| 80 // setting only stack frame ID and type ID, the real entry can be found. | |
| 81 Entry entry; | |
| 82 entry.stack_frame_id = stack_frame_id; | |
| 83 entry.type_id = type_id; | |
| 84 auto it = entries.find(entry); | |
| 85 | |
| 86 ASSERT_NE(entries.end(), it) << "No entry found for sf = " << stack_frame_id | |
| 87 << ", type = " << type_id << "."; | |
| 88 ASSERT_EQ(expected.size, it->size) << "Wrong size for sf = " << stack_frame_id | |
| 89 << ", type = " << type_id << "."; | |
| 90 ASSERT_EQ(expected.count, it->count) | |
| 91 << "Wrong count for sf = " << stack_frame_id << ", type = " << type_id | |
| 92 << "."; | |
| 93 } | |
| 94 | |
| 95 // Given a desired stack frame ID and type ID, asserts that no entry was dumped | |
| 96 // for that that particular combination of stack frame and type. | |
| 97 void AssertNotDumped(const std::set<Entry>& entries, | |
| 98 int stack_frame_id, | |
| 99 int type_id) { | |
| 100 // The comparison operator for |Entry| does not take size into account, so by | |
| 101 // setting only stack frame ID and type ID, the real entry can be found. | |
| 102 Entry entry; | |
| 103 entry.stack_frame_id = stack_frame_id; | |
| 104 entry.type_id = type_id; | |
| 105 auto it = entries.find(entry); | |
| 106 ASSERT_EQ(entries.end(), it) | |
| 107 << "Entry should not be present for sf = " << stack_frame_id | |
| 108 << ", type = " << type_id << "."; | |
| 109 } | |
| 110 | |
| 111 TEST(HeapDumpWriterTest, BacktraceIndex) { | |
| 112 Entry entry; | |
| 113 entry.stack_frame_id = -1; // -1 means empty backtrace. | |
| 114 entry.type_id = 0; | |
| 115 entry.size = 1; | |
| 116 entry.count = 1; | |
| 117 | |
| 118 std::unique_ptr<const DictionaryValue> json_entry = | |
| 119 WriteAndReadBackEntry(entry); | |
| 120 | |
| 121 // For an empty backtrace, the "bt" key cannot reference a stack frame. | |
| 122 // Instead it should be set to the empty string. | |
| 123 std::string backtrace_index; | |
| 124 ASSERT_TRUE(json_entry->GetString("bt", &backtrace_index)); | |
| 125 ASSERT_EQ("", backtrace_index); | |
| 126 | |
| 127 // Also verify that a non-negative backtrace index is dumped properly. | |
| 128 entry.stack_frame_id = 2; | |
| 129 json_entry = WriteAndReadBackEntry(entry); | |
| 130 ASSERT_TRUE(json_entry->GetString("bt", &backtrace_index)); | |
| 131 ASSERT_EQ("2", backtrace_index); | |
| 132 } | |
| 133 | |
| 134 TEST(HeapDumpWriterTest, TypeId) { | |
| 135 Entry entry; | |
| 136 entry.type_id = -1; // -1 means sum over all types. | |
| 137 entry.stack_frame_id = 0; | |
| 138 entry.size = 1; | |
| 139 entry.count = 1; | |
| 140 | |
| 141 std::unique_ptr<const DictionaryValue> json_entry = | |
| 142 WriteAndReadBackEntry(entry); | |
| 143 | |
| 144 // Entries for the cumulative size of all types should not have the "type" | |
| 145 // key set. | |
| 146 ASSERT_FALSE(json_entry->HasKey("type")); | |
| 147 | |
| 148 // Also verify that a non-negative type ID is dumped properly. | |
| 149 entry.type_id = 2; | |
| 150 json_entry = WriteAndReadBackEntry(entry); | |
| 151 std::string type_id; | |
| 152 ASSERT_TRUE(json_entry->GetString("type", &type_id)); | |
| 153 ASSERT_EQ("2", type_id); | |
| 154 } | |
| 155 | |
| 156 TEST(HeapDumpWriterTest, SizeAndCountAreHexadecimal) { | |
| 157 // Take a number between 2^63 and 2^64 (or between 2^31 and 2^32 if |size_t| | |
| 158 // is not 64 bits). | |
| 159 const size_t large_value = | |
| 160 sizeof(size_t) == 8 ? 0xffffffffffffffc5 : 0xffffff9d; | |
| 161 const char* large_value_str = | |
| 162 sizeof(size_t) == 8 ? "ffffffffffffffc5" : "ffffff9d"; | |
| 163 Entry entry; | |
| 164 entry.type_id = 0; | |
| 165 entry.stack_frame_id = 0; | |
| 166 entry.size = large_value; | |
| 167 entry.count = large_value; | |
| 168 | |
| 169 std::unique_ptr<const DictionaryValue> json_entry = | |
| 170 WriteAndReadBackEntry(entry); | |
| 171 | |
| 172 std::string size; | |
| 173 ASSERT_TRUE(json_entry->GetString("size", &size)); | |
| 174 ASSERT_EQ(large_value_str, size); | |
| 175 | |
| 176 std::string count; | |
| 177 ASSERT_TRUE(json_entry->GetString("count", &count)); | |
| 178 ASSERT_EQ(large_value_str, count); | |
| 179 } | |
| 180 | |
| 181 TEST(HeapDumpWriterTest, BacktraceTypeNameTable) { | |
| 182 hash_map<AllocationContext, AllocationMetrics> metrics_by_context; | |
| 183 | |
| 184 AllocationContext ctx; | |
| 185 ctx.backtrace.frames[0] = kBrowserMain; | |
| 186 ctx.backtrace.frames[1] = kCreateWidget; | |
| 187 ctx.backtrace.frame_count = 2; | |
| 188 ctx.type_name = kInt; | |
| 189 | |
| 190 // 10 bytes with context { type: int, bt: [BrowserMain, CreateWidget] }. | |
| 191 metrics_by_context[ctx] = {10, 5}; | |
| 192 | |
| 193 ctx.type_name = kBool; | |
| 194 | |
| 195 // 18 bytes with context { type: bool, bt: [BrowserMain, CreateWidget] }. | |
| 196 metrics_by_context[ctx] = {18, 18}; | |
| 197 | |
| 198 ctx.backtrace.frames[0] = kRendererMain; | |
| 199 ctx.backtrace.frames[1] = kInitialize; | |
| 200 ctx.backtrace.frame_count = 2; | |
| 201 | |
| 202 // 30 bytes with context { type: bool, bt: [RendererMain, Initialize] }. | |
| 203 metrics_by_context[ctx] = {30, 30}; | |
| 204 | |
| 205 ctx.type_name = kString; | |
| 206 | |
| 207 // 19 bytes with context { type: string, bt: [RendererMain, Initialize] }. | |
| 208 metrics_by_context[ctx] = {19, 4}; | |
| 209 | |
| 210 // At this point the heap looks like this: | |
| 211 // | |
| 212 // | | CrWidget <- BrMain | Init <- RenMain | Sum | | |
| 213 // +--------+--------------------+-----------------+-------------+ | |
| 214 // | | size count | size count | size count | | |
| 215 // | int | 10 5 | 0 0 | 10 5 | | |
| 216 // | bool | 18 18 | 30 30 | 48 48 | | |
| 217 // | string | 0 0 | 19 4 | 19 4 | | |
| 218 // +--------+--------------------+-----------------+-------------+ | |
| 219 // | Sum | 28 23 | 49 34 | 77 57 | | |
| 220 | |
| 221 auto stack_frame_deduplicator = WrapUnique(new StackFrameDeduplicator); | |
| 222 auto type_name_deduplicator = WrapUnique(new TypeNameDeduplicator); | |
| 223 HeapDumpWriter writer(stack_frame_deduplicator.get(), | |
| 224 type_name_deduplicator.get(), | |
| 225 10u); | |
| 226 const std::set<Entry>& dump = writer.Summarize(metrics_by_context); | |
| 227 | |
| 228 // Get the indices of the backtraces and types by adding them again to the | |
| 229 // deduplicator. Because they were added before, the same number is returned. | |
| 230 StackFrame bt0[] = {kRendererMain, kInitialize}; | |
| 231 StackFrame bt1[] = {kBrowserMain, kCreateWidget}; | |
| 232 int bt_renderer_main = stack_frame_deduplicator->Insert(bt0, bt0 + 1); | |
| 233 int bt_browser_main = stack_frame_deduplicator->Insert(bt1, bt1 + 1); | |
| 234 int bt_renderer_main_initialize = | |
| 235 stack_frame_deduplicator->Insert(bt0, bt0 + 2); | |
| 236 int bt_browser_main_create_widget = | |
| 237 stack_frame_deduplicator->Insert(bt1, bt1 + 2); | |
| 238 int type_id_int = type_name_deduplicator->Insert(kInt); | |
| 239 int type_id_bool = type_name_deduplicator->Insert(kBool); | |
| 240 int type_id_string = type_name_deduplicator->Insert(kString); | |
| 241 | |
| 242 // Full heap should have size 77. | |
| 243 AssertSizeAndCountEq(dump, -1, -1, {77, 57}); | |
| 244 | |
| 245 // 49 bytes in 34 chunks were allocated in RendererMain and children. Also | |
| 246 // check the type breakdown. | |
| 247 AssertSizeAndCountEq(dump, bt_renderer_main, -1, {49, 34}); | |
| 248 AssertSizeAndCountEq(dump, bt_renderer_main, type_id_bool, {30, 30}); | |
| 249 AssertSizeAndCountEq(dump, bt_renderer_main, type_id_string, {19, 4}); | |
| 250 | |
| 251 // 28 bytes in 23 chunks were allocated in BrowserMain and children. Also | |
| 252 // check the type breakdown. | |
| 253 AssertSizeAndCountEq(dump, bt_browser_main, -1, {28, 23}); | |
| 254 AssertSizeAndCountEq(dump, bt_browser_main, type_id_int, {10, 5}); | |
| 255 AssertSizeAndCountEq(dump, bt_browser_main, type_id_bool, {18, 18}); | |
| 256 | |
| 257 // In this test all bytes are allocated in leaf nodes, so check again one | |
| 258 // level deeper. | |
| 259 AssertSizeAndCountEq(dump, bt_renderer_main_initialize, -1, {49, 34}); | |
| 260 AssertSizeAndCountEq(dump, bt_renderer_main_initialize, type_id_bool, | |
| 261 {30, 30}); | |
| 262 AssertSizeAndCountEq(dump, bt_renderer_main_initialize, type_id_string, | |
| 263 {19, 4}); | |
| 264 AssertSizeAndCountEq(dump, bt_browser_main_create_widget, -1, {28, 23}); | |
| 265 AssertSizeAndCountEq(dump, bt_browser_main_create_widget, type_id_int, | |
| 266 {10, 5}); | |
| 267 AssertSizeAndCountEq(dump, bt_browser_main_create_widget, type_id_bool, | |
| 268 {18, 18}); | |
| 269 | |
| 270 // The type breakdown of the entrie heap should have been dumped as well. | |
| 271 AssertSizeAndCountEq(dump, -1, type_id_int, {10, 5}); | |
| 272 AssertSizeAndCountEq(dump, -1, type_id_bool, {48, 48}); | |
| 273 AssertSizeAndCountEq(dump, -1, type_id_string, {19, 4}); | |
| 274 } | |
| 275 | |
| 276 TEST(HeapDumpWriterTest, InsignificantValuesNotDumped) { | |
| 277 hash_map<AllocationContext, AllocationMetrics> metrics_by_context; | |
| 278 | |
| 279 AllocationContext ctx; | |
| 280 ctx.backtrace.frames[0] = kBrowserMain; | |
| 281 ctx.backtrace.frames[1] = kCreateWidget; | |
| 282 ctx.backtrace.frame_count = 2; | |
| 283 | |
| 284 // 0.5 KiB and 1 chunk in BrowserMain -> CreateWidget itself. | |
| 285 metrics_by_context[ctx] = {512, 1}; | |
| 286 | |
| 287 // 1 MiB and 1 chunk in BrowserMain -> CreateWidget -> GetBitmap. | |
| 288 ctx.backtrace.frames[2] = kGetBitmap; | |
| 289 ctx.backtrace.frame_count = 3; | |
| 290 metrics_by_context[ctx] = {1024 * 1024, 1}; | |
| 291 | |
| 292 // 400B and 1 chunk in BrowserMain -> CreateWidget -> Initialize. | |
| 293 ctx.backtrace.frames[2] = kInitialize; | |
| 294 ctx.backtrace.frame_count = 3; | |
| 295 metrics_by_context[ctx] = {400, 1}; | |
| 296 | |
| 297 auto stack_frame_deduplicator = WrapUnique(new StackFrameDeduplicator); | |
| 298 auto type_name_deduplicator = WrapUnique(new TypeNameDeduplicator); | |
| 299 HeapDumpWriter writer(stack_frame_deduplicator.get(), | |
| 300 type_name_deduplicator.get(), | |
| 301 512u); | |
| 302 const std::set<Entry>& dump = writer.Summarize(metrics_by_context); | |
| 303 | |
| 304 // Get the indices of the backtraces and types by adding them again to the | |
| 305 // deduplicator. Because they were added before, the same number is returned. | |
| 306 StackFrame bt0[] = {kBrowserMain, kCreateWidget, kGetBitmap}; | |
| 307 StackFrame bt1[] = {kBrowserMain, kCreateWidget, kInitialize}; | |
| 308 int bt_browser_main = stack_frame_deduplicator->Insert(bt0, bt0 + 1); | |
| 309 int bt_create_widget = stack_frame_deduplicator->Insert(bt0, bt0 + 2); | |
| 310 int bt_get_bitmap = stack_frame_deduplicator->Insert(bt0, bt0 + 3); | |
| 311 int bt_initialize = stack_frame_deduplicator->Insert(bt1, bt1 + 3); | |
| 312 | |
| 313 // Full heap should have size of 1 MiB + .9 KiB and 3 chunks. | |
| 314 AssertSizeAndCountEq(dump, -1, -1 /* No type specified */, | |
| 315 {1024 * 1024 + 512 + 400, 3}); | |
| 316 | |
| 317 // |GetBitmap| allocated 1 MiB and 1 chunk. | |
| 318 AssertSizeAndCountEq(dump, bt_get_bitmap, -1, {1024 * 1024, 1}); | |
| 319 | |
| 320 // Because |GetBitmap| was dumped, all of its parent nodes should have been | |
| 321 // dumped too. |CreateWidget| has 1 MiB in |GetBitmap|, 400 bytes in | |
| 322 // |Initialize|, and 512 bytes of its own and each in 1 chunk. | |
| 323 AssertSizeAndCountEq(dump, bt_create_widget, -1, | |
| 324 {1024 * 1024 + 400 + 512, 3}); | |
| 325 AssertSizeAndCountEq(dump, bt_browser_main, -1, {1024 * 1024 + 400 + 512, 3}); | |
| 326 | |
| 327 // Initialize was not significant, it should not have been dumped. | |
| 328 AssertNotDumped(dump, bt_initialize, -1); | |
| 329 } | |
| 330 | |
| 331 } // namespace internal | |
| 332 } // namespace trace_event | |
| 333 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2650863003:
[tracing] Switch to new heap dump format. (Closed)
