OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 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_event_writer.h" | |
6 | |
7 #include <stdint.h> | |
8 | |
9 #include <tuple> | |
10 #include <unordered_map> | |
11 | |
12 #include "base/bind.h" | |
13 #include "base/memory/ptr_util.h" | |
14 #include "base/numerics/safe_conversions.h" | |
15 #include "base/trace_event/heap_profiler_serialization_state.h" | |
16 #include "base/trace_event/heap_profiler_stack_frame_deduplicator.h" | |
17 #include "base/trace_event/heap_profiler_string_deduplicator.h" | |
18 #include "base/trace_event/heap_profiler_type_name_deduplicator.h" | |
19 #include "base/trace_event/sharded_allocation_register.h" | |
20 #include "base/trace_event/trace_event_argument.h" | |
21 | |
22 namespace base { | |
23 namespace trace_event { | |
24 | |
25 namespace { | |
26 | |
27 struct AggregationKey { | |
28 int backtrace_id; | |
29 int type_id; | |
30 | |
31 struct Hasher { | |
32 size_t operator()(const AggregationKey& key) const { | |
33 return base::HashInts(key.backtrace_id, key.type_id); | |
34 } | |
35 }; | |
36 | |
37 bool operator==(const AggregationKey& other) const { | |
38 return backtrace_id == other.backtrace_id && type_id == other.type_id; | |
39 } | |
40 }; | |
41 | |
42 } // namespace | |
43 | |
44 std::unique_ptr<TracedValue> SerializeHeapDump( | |
45 const ShardedAllocationRegister& allocation_register, | |
46 HeapProfilerSerializationState* serialization_state) { | |
47 // Aggregate allocations by {backtrace_id, type_id} key. | |
48 using MetricsMap = std::unordered_map<AggregationKey, AllocationMetrics, | |
Primiano Tucci (use gerrit)
2017/05/30 18:50:53
brett's PSA (see https://chromium.googlesource.com
DmitrySkiba
2017/06/05 00:50:18
Potentially there can be a lot of lookups, if, for
| |
49 AggregationKey::Hasher>; | |
50 MetricsMap metrics_by_key; | |
51 | |
52 auto visit_allocation = | |
53 [](HeapProfilerSerializationState* serialization_state, | |
54 MetricsMap* metrics_by_key, | |
55 const AllocationRegister::Allocation& allocation) { | |
56 int backtrace_id = | |
57 serialization_state->stack_frame_deduplicator()->Insert( | |
58 std::begin(allocation.context.backtrace.frames), | |
59 std::begin(allocation.context.backtrace.frames) + | |
60 allocation.context.backtrace.frame_count); | |
61 | |
62 int type_id = serialization_state->type_name_deduplicator()->Insert( | |
63 allocation.context.type_name); | |
64 | |
65 AggregationKey key = {backtrace_id, type_id}; | |
66 AllocationMetrics& metrics = (*metrics_by_key)[key]; | |
67 metrics.size += allocation.size; | |
68 metrics.count += 1; | |
69 }; | |
70 allocation_register.VisitAllocations(base::BindRepeating( | |
71 visit_allocation, base::Unretained(serialization_state), | |
72 base::Unretained(&metrics_by_key))); | |
73 | |
74 auto traced_value = MakeUnique<TracedValue>(); | |
75 | |
76 traced_value->BeginArray("nodes"); | |
77 for (const auto& key_and_metrics : metrics_by_key) | |
78 traced_value->AppendInteger(key_and_metrics.first.backtrace_id); | |
79 traced_value->EndArray(); | |
80 | |
81 traced_value->BeginArray("types"); | |
82 for (const auto& key_and_metrics : metrics_by_key) | |
83 traced_value->AppendInteger(key_and_metrics.first.type_id); | |
84 traced_value->EndArray(); | |
85 | |
86 traced_value->BeginArray("counts"); | |
87 for (const auto& key_and_metrics : metrics_by_key) | |
88 traced_value->AppendInteger( | |
89 saturated_cast<int>(key_and_metrics.second.count)); | |
90 traced_value->EndArray(); | |
91 | |
92 traced_value->BeginArray("sizes"); | |
93 for (const auto& key_and_metrics : metrics_by_key) | |
94 traced_value->AppendInteger( | |
95 saturated_cast<int>(key_and_metrics.second.size)); | |
96 traced_value->EndArray(); | |
97 | |
98 return traced_value; | |
99 } | |
100 | |
101 std::unique_ptr<TracedValue> SerializeHeapProfileEventData( | |
102 const SerializedHeapDumpsMap& heap_dumps, | |
103 HeapProfilerSerializationState* serialization_state) { | |
104 auto traced_value = MakeUnique<TracedValue>(); | |
105 | |
106 // See brief description of the format in the header file. | |
107 traced_value->SetInteger("version", 1); | |
108 | |
109 traced_value->BeginDictionary("allocators"); | |
110 for (const auto& name_and_dump : heap_dumps) { | |
111 traced_value->SetValueWithCopiedName(name_and_dump.first.c_str(), | |
112 *name_and_dump.second); | |
113 } | |
114 traced_value->EndDictionary(); | |
115 | |
116 traced_value->BeginDictionary("maps"); | |
117 | |
118 if (auto* deduplicator = serialization_state->stack_frame_deduplicator()) { | |
119 traced_value->BeginArray("nodes"); | |
120 deduplicator->SerializeIncrementally(&*traced_value); | |
121 traced_value->EndArray(); | |
122 } | |
123 | |
124 if (auto* deduplicator = serialization_state->type_name_deduplicator()) { | |
125 traced_value->BeginArray("types"); | |
126 deduplicator->SerializeIncrementally(&*traced_value); | |
127 traced_value->EndArray(); | |
128 } | |
129 | |
130 if (auto* deduplicator = serialization_state->string_deduplicator()) { | |
131 traced_value->BeginArray("strings"); | |
132 deduplicator->SerializeIncrementally(&*traced_value); | |
133 traced_value->EndArray(); | |
134 } | |
135 | |
136 traced_value->EndDictionary(); | |
137 | |
138 return traced_value; | |
139 } | |
140 | |
141 } // namespace trace_event | |
142 } // namespace base | |
OLD | NEW |