diff options
Diffstat (limited to 'base/trace_event/malloc_dump_provider.cc')
| -rw-r--r-- | base/trace_event/malloc_dump_provider.cc | 189 |
1 files changed, 189 insertions, 0 deletions
diff --git a/base/trace_event/malloc_dump_provider.cc b/base/trace_event/malloc_dump_provider.cc new file mode 100644 index 0000000000..46fdb3e214 --- /dev/null +++ b/base/trace_event/malloc_dump_provider.cc @@ -0,0 +1,189 @@ +// Copyright 2015 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. + +#include "base/trace_event/malloc_dump_provider.h" + +#include <stddef.h> + +#include <unordered_map> + +#include "base/allocator/allocator_extension.h" +#include "base/allocator/buildflags.h" +#include "base/debug/profiler.h" +#include "base/trace_event/process_memory_dump.h" +#include "base/trace_event/trace_event_argument.h" +#include "build/build_config.h" + +#if defined(OS_MACOSX) +#include <malloc/malloc.h> +#else +#include <malloc.h> +#endif +#if defined(OS_WIN) +#include <windows.h> +#endif + +namespace base { +namespace trace_event { + +namespace { +#if defined(OS_WIN) +// A structure containing some information about a given heap. +struct WinHeapInfo { + size_t committed_size; + size_t uncommitted_size; + size_t allocated_size; + size_t block_count; +}; + +// NOTE: crbug.com/665516 +// Unfortunately, there is no safe way to collect information from secondary +// heaps due to limitations and racy nature of this piece of WinAPI. +void WinHeapMemoryDumpImpl(WinHeapInfo* crt_heap_info) { + // Iterate through whichever heap our CRT is using. + HANDLE crt_heap = reinterpret_cast<HANDLE>(_get_heap_handle()); + ::HeapLock(crt_heap); + PROCESS_HEAP_ENTRY heap_entry; + heap_entry.lpData = nullptr; + // Walk over all the entries in the main heap. + while (::HeapWalk(crt_heap, &heap_entry) != FALSE) { + if ((heap_entry.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0) { + crt_heap_info->allocated_size += heap_entry.cbData; + crt_heap_info->block_count++; + } else if ((heap_entry.wFlags & PROCESS_HEAP_REGION) != 0) { + crt_heap_info->committed_size += heap_entry.Region.dwCommittedSize; + crt_heap_info->uncommitted_size += heap_entry.Region.dwUnCommittedSize; + } + } + CHECK(::HeapUnlock(crt_heap) == TRUE); +} +#endif // defined(OS_WIN) +} // namespace + +// static +const char MallocDumpProvider::kAllocatedObjects[] = "malloc/allocated_objects"; + +// static +MallocDumpProvider* MallocDumpProvider::GetInstance() { + return Singleton<MallocDumpProvider, + LeakySingletonTraits<MallocDumpProvider>>::get(); +} + +MallocDumpProvider::MallocDumpProvider() = default; +MallocDumpProvider::~MallocDumpProvider() = default; + +// Called at trace dump point time. Creates a snapshot the memory counters for +// the current process. +bool MallocDumpProvider::OnMemoryDump(const MemoryDumpArgs& args, + ProcessMemoryDump* pmd) { + { + base::AutoLock auto_lock(emit_metrics_on_memory_dump_lock_); + if (!emit_metrics_on_memory_dump_) + return true; + } + + size_t total_virtual_size = 0; + size_t resident_size = 0; + size_t allocated_objects_size = 0; + size_t allocated_objects_count = 0; +#if defined(USE_TCMALLOC) + bool res = + allocator::GetNumericProperty("generic.heap_size", &total_virtual_size); + DCHECK(res); + res = allocator::GetNumericProperty("generic.total_physical_bytes", + &resident_size); + DCHECK(res); + res = allocator::GetNumericProperty("generic.current_allocated_bytes", + &allocated_objects_size); + DCHECK(res); +#elif defined(OS_MACOSX) || defined(OS_IOS) + malloc_statistics_t stats = {0}; + malloc_zone_statistics(nullptr, &stats); + total_virtual_size = stats.size_allocated; + allocated_objects_size = stats.size_in_use; + + // Resident size is approximated pretty well by stats.max_size_in_use. + // However, on macOS, freed blocks are both resident and reusable, which is + // semantically equivalent to deallocated. The implementation of libmalloc + // will also only hold a fixed number of freed regions before actually + // starting to deallocate them, so stats.max_size_in_use is also not + // representative of the peak size. As a result, stats.max_size_in_use is + // typically somewhere between actually resident [non-reusable] pages, and + // peak size. This is not very useful, so we just use stats.size_in_use for + // resident_size, even though it's an underestimate and fails to account for + // fragmentation. See + // https://bugs.chromium.org/p/chromium/issues/detail?id=695263#c1. + resident_size = stats.size_in_use; +#elif defined(OS_WIN) + // This is too expensive on Windows, crbug.com/780735. + if (args.level_of_detail == MemoryDumpLevelOfDetail::DETAILED) { + WinHeapInfo main_heap_info = {}; + WinHeapMemoryDumpImpl(&main_heap_info); + total_virtual_size = + main_heap_info.committed_size + main_heap_info.uncommitted_size; + // Resident size is approximated with committed heap size. Note that it is + // possible to do this with better accuracy on windows by intersecting the + // working set with the virtual memory ranges occuipied by the heap. It's + // not clear that this is worth it, as it's fairly expensive to do. + resident_size = main_heap_info.committed_size; + allocated_objects_size = main_heap_info.allocated_size; + allocated_objects_count = main_heap_info.block_count; + } +#elif defined(OS_FUCHSIA) +// TODO(fuchsia): Port, see https://crbug.com/706592. +#else + struct mallinfo info = mallinfo(); + DCHECK_GE(info.arena + info.hblkhd, info.uordblks); + + // In case of Android's jemalloc |arena| is 0 and the outer pages size is + // reported by |hblkhd|. In case of dlmalloc the total is given by + // |arena| + |hblkhd|. For more details see link: http://goo.gl/fMR8lF. + total_virtual_size = info.arena + info.hblkhd; + resident_size = info.uordblks; + + // Total allocated space is given by |uordblks|. + allocated_objects_size = info.uordblks; +#endif + + MemoryAllocatorDump* outer_dump = pmd->CreateAllocatorDump("malloc"); + outer_dump->AddScalar("virtual_size", MemoryAllocatorDump::kUnitsBytes, + total_virtual_size); + outer_dump->AddScalar(MemoryAllocatorDump::kNameSize, + MemoryAllocatorDump::kUnitsBytes, resident_size); + + MemoryAllocatorDump* inner_dump = pmd->CreateAllocatorDump(kAllocatedObjects); + inner_dump->AddScalar(MemoryAllocatorDump::kNameSize, + MemoryAllocatorDump::kUnitsBytes, + allocated_objects_size); + if (allocated_objects_count != 0) { + inner_dump->AddScalar(MemoryAllocatorDump::kNameObjectCount, + MemoryAllocatorDump::kUnitsObjects, + allocated_objects_count); + } + + if (resident_size > allocated_objects_size) { + // Explicitly specify why is extra memory resident. In tcmalloc it accounts + // for free lists and caches. In mac and ios it accounts for the + // fragmentation and metadata. + MemoryAllocatorDump* other_dump = + pmd->CreateAllocatorDump("malloc/metadata_fragmentation_caches"); + other_dump->AddScalar(MemoryAllocatorDump::kNameSize, + MemoryAllocatorDump::kUnitsBytes, + resident_size - allocated_objects_size); + } + return true; +} + +void MallocDumpProvider::EnableMetrics() { + base::AutoLock auto_lock(emit_metrics_on_memory_dump_lock_); + emit_metrics_on_memory_dump_ = true; +} + +void MallocDumpProvider::DisableMetrics() { + base::AutoLock auto_lock(emit_metrics_on_memory_dump_lock_); + emit_metrics_on_memory_dump_ = false; +} + +} // namespace trace_event +} // namespace base |