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

Side by Side Diff: third_party/WebKit/Source/platform/PartitionAllocMemoryDumpProvider.cpp

Issue 2890363003: Enable sharding of AllocationRegister on desktop. (Closed)
Patch Set: comment from primiano. Created 3 years, 7 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 unified diff | Download patch
OLDNEW
1 // Copyright 2015 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "platform/PartitionAllocMemoryDumpProvider.h" 5 #include "platform/PartitionAllocMemoryDumpProvider.h"
6 6
7 #include <unordered_map> 7 #include <unordered_map>
8 8
9 #include "base/strings/stringprintf.h" 9 #include "base/strings/stringprintf.h"
10 #include "base/trace_event/heap_profiler_allocation_context.h"
11 #include "base/trace_event/heap_profiler_allocation_context_tracker.h" 10 #include "base/trace_event/heap_profiler_allocation_context_tracker.h"
12 #include "base/trace_event/heap_profiler_allocation_register.h" 11 #include "base/trace_event/heap_profiler_allocation_register.h"
13 #include "base/trace_event/process_memory_dump.h" 12 #include "base/trace_event/process_memory_dump.h"
13 #include "base/trace_event/sharded_allocation_register.h"
14 #include "base/trace_event/trace_event_memory_overhead.h" 14 #include "base/trace_event/trace_event_memory_overhead.h"
15 #include "platform/wtf/allocator/Partitions.h" 15 #include "platform/wtf/allocator/Partitions.h"
16 #include "platform/wtf/text/WTFString.h" 16 #include "platform/wtf/text/WTFString.h"
17 17
18 namespace blink { 18 namespace blink {
19 19
20 namespace { 20 namespace {
21 21
22 using namespace WTF; 22 using namespace WTF;
23 23
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after
128 DEFINE_STATIC_LOCAL(PartitionAllocMemoryDumpProvider, instance, ()); 128 DEFINE_STATIC_LOCAL(PartitionAllocMemoryDumpProvider, instance, ());
129 return &instance; 129 return &instance;
130 } 130 }
131 131
132 bool PartitionAllocMemoryDumpProvider::OnMemoryDump( 132 bool PartitionAllocMemoryDumpProvider::OnMemoryDump(
133 const base::trace_event::MemoryDumpArgs& args, 133 const base::trace_event::MemoryDumpArgs& args,
134 base::trace_event::ProcessMemoryDump* memory_dump) { 134 base::trace_event::ProcessMemoryDump* memory_dump) {
135 using base::trace_event::MemoryDumpLevelOfDetail; 135 using base::trace_event::MemoryDumpLevelOfDetail;
136 136
137 MemoryDumpLevelOfDetail level_of_detail = args.level_of_detail; 137 MemoryDumpLevelOfDetail level_of_detail = args.level_of_detail;
138 if (is_heap_profiling_enabled_) { 138 if (allocation_register_->IsEnabled()) {
139 // Overhead should always be reported, regardless of light vs. heavy. 139 // Overhead should always be reported, regardless of light vs. heavy.
140 base::trace_event::TraceEventMemoryOverhead overhead; 140 base::trace_event::TraceEventMemoryOverhead overhead;
141 std::unordered_map<base::trace_event::AllocationContext, 141 std::unordered_map<base::trace_event::AllocationContext,
142 base::trace_event::AllocationMetrics> 142 base::trace_event::AllocationMetrics>
143 metrics_by_context; 143 metrics_by_context;
144 { 144 // Dump only the overhead estimation in non-detailed dumps.
145 MutexLocker locker(allocation_register_mutex_); 145 if (level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
146 // Dump only the overhead estimation in non-detailed dumps. 146 allocation_register_->UpdateAndReturnsMetrics(metrics_by_context);
147 if (level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
148 for (const auto& alloc_size : *allocation_register_) {
149 base::trace_event::AllocationMetrics& metrics =
150 metrics_by_context[alloc_size.context];
151 metrics.size += alloc_size.size;
152 metrics.count++;
153 }
154 }
155 allocation_register_->EstimateTraceMemoryOverhead(&overhead);
156 } 147 }
148 allocation_register_->EstimateTraceMemoryOverhead(&overhead);
157 memory_dump->DumpHeapUsage(metrics_by_context, overhead, "partition_alloc"); 149 memory_dump->DumpHeapUsage(metrics_by_context, overhead, "partition_alloc");
158 } 150 }
159 151
160 PartitionStatsDumperImpl partition_stats_dumper(memory_dump, level_of_detail); 152 PartitionStatsDumperImpl partition_stats_dumper(memory_dump, level_of_detail);
161 153
162 base::trace_event::MemoryAllocatorDump* partitions_dump = 154 base::trace_event::MemoryAllocatorDump* partitions_dump =
163 memory_dump->CreateAllocatorDump(base::StringPrintf( 155 memory_dump->CreateAllocatorDump(base::StringPrintf(
164 "%s/%s", kPartitionAllocDumpName, kPartitionsDumpName)); 156 "%s/%s", kPartitionAllocDumpName, kPartitionsDumpName));
165 157
166 // This method calls memoryStats.partitionsDumpBucketStats with memory 158 // This method calls memoryStats.partitionsDumpBucketStats with memory
167 // statistics. 159 // statistics.
168 WTF::Partitions::DumpMemoryStats( 160 WTF::Partitions::DumpMemoryStats(
169 level_of_detail != MemoryDumpLevelOfDetail::DETAILED, 161 level_of_detail != MemoryDumpLevelOfDetail::DETAILED,
170 &partition_stats_dumper); 162 &partition_stats_dumper);
171 163
172 base::trace_event::MemoryAllocatorDump* allocated_objects_dump = 164 base::trace_event::MemoryAllocatorDump* allocated_objects_dump =
173 memory_dump->CreateAllocatorDump(Partitions::kAllocatedObjectPoolName); 165 memory_dump->CreateAllocatorDump(Partitions::kAllocatedObjectPoolName);
174 allocated_objects_dump->AddScalar("size", "bytes", 166 allocated_objects_dump->AddScalar("size", "bytes",
175 partition_stats_dumper.TotalActiveBytes()); 167 partition_stats_dumper.TotalActiveBytes());
176 memory_dump->AddOwnershipEdge(allocated_objects_dump->guid(), 168 memory_dump->AddOwnershipEdge(allocated_objects_dump->guid(),
177 partitions_dump->guid()); 169 partitions_dump->guid());
178 170
179 return true; 171 return true;
180 } 172 }
181 173
182 // |m_allocationRegister| should be initialized only when necessary to avoid 174 // |m_allocationRegister| should be initialized only when necessary to avoid
183 // waste of memory. 175 // waste of memory.
184 PartitionAllocMemoryDumpProvider::PartitionAllocMemoryDumpProvider() 176 PartitionAllocMemoryDumpProvider::PartitionAllocMemoryDumpProvider()
185 : allocation_register_(nullptr), is_heap_profiling_enabled_(false) {} 177 : allocation_register_(new base::trace_event::ShardedAllocationRegister) {}
186 178
187 PartitionAllocMemoryDumpProvider::~PartitionAllocMemoryDumpProvider() {} 179 PartitionAllocMemoryDumpProvider::~PartitionAllocMemoryDumpProvider() {}
188 180
189 void PartitionAllocMemoryDumpProvider::OnHeapProfilingEnabled(bool enabled) { 181 void PartitionAllocMemoryDumpProvider::OnHeapProfilingEnabled(bool enabled) {
190 if (enabled) { 182 if (enabled) {
191 { 183 if (!allocation_register_->IsInitialized())
192 MutexLocker locker(allocation_register_mutex_); 184 allocation_register_->Initialize();
193 if (!allocation_register_)
194 allocation_register_.reset(new base::trace_event::AllocationRegister());
195 }
196 WTF::PartitionAllocHooks::SetAllocationHook(ReportAllocation); 185 WTF::PartitionAllocHooks::SetAllocationHook(ReportAllocation);
197 WTF::PartitionAllocHooks::SetFreeHook(ReportFree); 186 WTF::PartitionAllocHooks::SetFreeHook(ReportFree);
198 } else { 187 } else {
199 WTF::PartitionAllocHooks::SetAllocationHook(nullptr); 188 WTF::PartitionAllocHooks::SetAllocationHook(nullptr);
200 WTF::PartitionAllocHooks::SetFreeHook(nullptr); 189 WTF::PartitionAllocHooks::SetFreeHook(nullptr);
201 } 190 }
202 is_heap_profiling_enabled_ = enabled; 191 allocation_register_->SetEnabled(enabled);
203 } 192 }
204 193
205 void PartitionAllocMemoryDumpProvider::insert(void* address, 194 void PartitionAllocMemoryDumpProvider::insert(void* address,
206 size_t size, 195 size_t size,
207 const char* type_name) { 196 const char* type_name) {
208 base::trace_event::AllocationContext context; 197 base::trace_event::AllocationContext context;
209 if (!base::trace_event::AllocationContextTracker:: 198 if (!base::trace_event::AllocationContextTracker::
210 GetInstanceForCurrentThread() 199 GetInstanceForCurrentThread()
211 ->GetContextSnapshot(&context)) 200 ->GetContextSnapshot(&context))
212 return; 201 return;
213 202
214 context.type_name = type_name; 203 context.type_name = type_name;
215 MutexLocker locker(allocation_register_mutex_); 204 if (!allocation_register_->IsEnabled())
216 if (allocation_register_) 205 return;
217 allocation_register_->Insert(address, size, context); 206 allocation_register_->Insert(address, size, context);
218 } 207 }
219 208
220 void PartitionAllocMemoryDumpProvider::Remove(void* address) { 209 void PartitionAllocMemoryDumpProvider::Remove(void* address) {
221 MutexLocker locker(allocation_register_mutex_); 210 if (!allocation_register_->IsEnabled())
222 if (allocation_register_) 211 return;
223 allocation_register_->Remove(address); 212 allocation_register_->Remove(address);
224 } 213 }
225 214
226 } // namespace blink 215 } // namespace blink
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698