blob: 6566cadd14f2ba12a3f25e30af655de2ded8d752 [file] [log] [blame]
// 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/memory_allocator_dump.h"
#include <string.h>
#include "base/format_macros.h"
#include "base/memory/ptr_util.h"
#include "base/strings/stringprintf.h"
#include "base/trace_event/memory_dump_manager.h"
#include "base/trace_event/memory_dump_provider.h"
#include "base/trace_event/process_memory_dump.h"
#include "base/trace_event/trace_event_argument.h"
#include "base/values.h"
namespace base {
namespace trace_event {
const char MemoryAllocatorDump::kNameSize[] = "size";
const char MemoryAllocatorDump::kNameObjectCount[] = "object_count";
const char MemoryAllocatorDump::kTypeScalar[] = "scalar";
const char MemoryAllocatorDump::kTypeString[] = "string";
const char MemoryAllocatorDump::kUnitsBytes[] = "bytes";
const char MemoryAllocatorDump::kUnitsObjects[] = "objects";
MemoryAllocatorDump::MemoryAllocatorDump(
const std::string& absolute_name,
MemoryDumpLevelOfDetail level_of_detail,
const MemoryAllocatorDumpGuid& guid)
: absolute_name_(absolute_name),
guid_(guid),
level_of_detail_(level_of_detail),
flags_(Flags::DEFAULT) {
// The |absolute_name| cannot be empty.
DCHECK(!absolute_name.empty());
// The |absolute_name| can contain slash separator, but not leading or
// trailing ones.
DCHECK(absolute_name[0] != '/' && *absolute_name.rbegin() != '/');
}
MemoryAllocatorDump::~MemoryAllocatorDump() {
}
void MemoryAllocatorDump::AddScalar(const char* name,
const char* units,
uint64_t value) {
entries_.emplace_back(name, units, value);
}
void MemoryAllocatorDump::AddString(const char* name,
const char* units,
const std::string& value) {
// String attributes are disabled in background mode.
if (level_of_detail_ == MemoryDumpLevelOfDetail::BACKGROUND) {
NOTREACHED();
return;
}
entries_.emplace_back(name, units, value);
}
void MemoryAllocatorDump::AsValueInto(TracedValue* value) const {
std::string string_conversion_buffer;
value->BeginDictionaryWithCopiedName(absolute_name_);
value->SetString("guid", guid_.ToString());
value->BeginDictionary("attrs");
for (const Entry& entry : entries_) {
value->BeginDictionaryWithCopiedName(entry.name);
switch (entry.entry_type) {
case Entry::kUint64:
SStringPrintf(&string_conversion_buffer, "%" PRIx64,
entry.value_uint64);
value->SetString("type", kTypeScalar);
value->SetString("units", entry.units);
value->SetString("value", string_conversion_buffer);
break;
case Entry::kString:
value->SetString("type", kTypeString);
value->SetString("units", entry.units);
value->SetString("value", entry.value_string);
break;
}
value->EndDictionary();
}
value->EndDictionary(); // "attrs": { ... }
if (flags_)
value->SetInteger("flags", flags_);
value->EndDictionary(); // "allocator_name/heap_subheap": { ... }
}
uint64_t MemoryAllocatorDump::GetSizeInternal() const {
if (cached_size_.has_value())
return *cached_size_;
for (const auto& entry : entries_) {
if (entry.entry_type == Entry::kUint64 && entry.units == kUnitsBytes &&
strcmp(entry.name.c_str(), kNameSize) == 0) {
cached_size_ = entry.value_uint64;
return entry.value_uint64;
}
}
return 0;
};
MemoryAllocatorDump::Entry::Entry() : entry_type(kString), value_uint64() {}
MemoryAllocatorDump::Entry::Entry(MemoryAllocatorDump::Entry&&) noexcept =
default;
MemoryAllocatorDump::Entry& MemoryAllocatorDump::Entry::operator=(
MemoryAllocatorDump::Entry&&) = default;
MemoryAllocatorDump::Entry::Entry(std::string name,
std::string units,
uint64_t value)
: name(name), units(units), entry_type(kUint64), value_uint64(value) {}
MemoryAllocatorDump::Entry::Entry(std::string name,
std::string units,
std::string value)
: name(name), units(units), entry_type(kString), value_string(value) {}
bool MemoryAllocatorDump::Entry::operator==(const Entry& rhs) const {
if (!(name == rhs.name && units == rhs.units && entry_type == rhs.entry_type))
return false;
switch (entry_type) {
case EntryType::kUint64:
return value_uint64 == rhs.value_uint64;
case EntryType::kString:
return value_string == rhs.value_string;
}
NOTREACHED();
return false;
}
void PrintTo(const MemoryAllocatorDump::Entry& entry, std::ostream* out) {
switch (entry.entry_type) {
case MemoryAllocatorDump::Entry::EntryType::kUint64:
*out << "<Entry(\"" << entry.name << "\", \"" << entry.units << "\", "
<< entry.value_uint64 << ")>";
return;
case MemoryAllocatorDump::Entry::EntryType::kString:
*out << "<Entry(\"" << entry.name << "\", \"" << entry.units << "\", \""
<< entry.value_string << "\")>";
return;
}
NOTREACHED();
}
} // namespace trace_event
} // namespace base