// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "fuchsia_web/webengine/browser/web_engine_memory_inspector.h"
#include <lib/fpromise/promise.h>
#include <lib/inspect/cpp/inspector.h>
#include <sstream>
#include "base/no_destructor.h"
#include "base/strings/string_number_conversions.h"
#include "base/trace_event/memory_dump_request_args.h"
#include "components/fuchsia_component_support/config_reader.h"
#include "services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation.h"
namespace {
std::vector<std::string> GetAllocatorDumpNamesFromConfig() {
const std::optional<base::Value::Dict>& config =
fuchsia_component_support::LoadPackageConfig();
if (!config)
return {};
const base::Value::List* names_list =
config->FindList("allocator-dump-names");
if (!names_list)
return {};
std::vector<std::string> names;
names.reserve(names_list->size());
for (auto& name : *names_list) {
names.push_back(name.GetString());
}
return names;
}
// List of allocator dump names to include.
const std::vector<std::string>& AllocatorDumpNames() {
static base::NoDestructor<std::vector<std::string>> allocator_dump_names(
GetAllocatorDumpNamesFromConfig());
return *allocator_dump_names;
}
// Returns true if every field in the supplied |dump|, and those of its
// children, are zero. Generally parent nodes summarize the total usage across
// all of their children, such that if the parent is all-zero then the children
// must also be all-zero. This implementation is optimized for the case in
// which that property holds, but also copes gracefully when it does not.
bool AreAllDumpEntriesZero(
const memory_instrumentation::mojom::AllocatorMemDump* dump) {
for (auto& it : dump->numeric_entries) {
if (it.second != 0u)
return false;
}
for (auto& it : dump->children) {
if (!AreAllDumpEntriesZero(it.second.get()))
return false;
}
return true;
}
// Creates a node |name|, under |parent|, populated recursively with the
// contents of |dump|. The returned tree of Nodes are emplace()d to be owned by
// the specified |owner|.
inspect::Node NodeFromAllocatorMemDump(
inspect::Inspector* owner,
inspect::Node* parent,
const std::string& name,
const memory_instrumentation::mojom::AllocatorMemDump* dump) {
auto node = parent->CreateChild(name);
// Add subordinate nodes for any children.
std::vector<const memory_instrumentation::mojom::AllocatorMemDump*> children;
children.reserve(dump->children.size());
for (auto& it : dump->children) {
// If a child contains no information then omit it.
if (AreAllDumpEntriesZero(it.second.get()))
continue;
children.push_back(it.second.get());
owner->emplace(
NodeFromAllocatorMemDump(owner, &node, it.first, it.second.get()));
}
// Publish the allocator-provided fields into the node. Entries are not
// published if there is a single child, with identical entries, to avoid
// redundancy in the emitted output.
bool same_as_child =
(children.size() == 1u &&
(*children.begin())->numeric_entries == dump->numeric_entries);
if (!same_as_child) {
for (auto& it : dump->numeric_entries) {
node.CreateUint(it.first, it.second, owner);
}
}
return node;
}
} // namespace
WebEngineMemoryInspector::WebEngineMemoryInspector(inspect::Node& parent_node) {
// Loading the allocator dump names from the config involves blocking I/O so
// trigger it to be done during construction, before the prohibition on
// blocking the main thread is applied.
AllocatorDumpNames();
node_ = parent_node.CreateLazyNode("memory", [this]() {
return fpromise::make_promise(fit::bind_member(
this, &WebEngineMemoryInspector::ResolveMemoryDumpPromise));
});
}
WebEngineMemoryInspector::~WebEngineMemoryInspector() = default;
fpromise::result<inspect::Inspector>
WebEngineMemoryInspector::ResolveMemoryDumpPromise(fpromise::context& context) {
// If there is a |dump_results_| then resolve the promise with it.
if (dump_results_) {
auto memory_dump = std::move(dump_results_);
return fpromise::ok(*memory_dump);
}
// If MemoryInstrumentation is not initialized then resolve an error.
auto* memory_instrumentation =
memory_instrumentation::MemoryInstrumentation::GetInstance();
if (!memory_instrumentation)
return fpromise::error();
// Request memory usage summaries for all processes, including details for
// any configured allocator dumps.
auto* coordinator = memory_instrumentation->GetCoordinator();
DCHECK(coordinator);
coordinator->RequestGlobalMemoryDump(
base::trace_event::MemoryDumpType::kSummaryOnly,
base::trace_event::MemoryDumpLevelOfDetail::kBackground,
base::trace_event::MemoryDumpDeterminism::kNone, AllocatorDumpNames(),
base::BindOnce(&WebEngineMemoryInspector::OnMemoryDumpComplete,
weak_this_.GetMutableWeakPtr(), base::TimeTicks::Now(),
context.suspend_task()));
return fpromise::pending();
}
void WebEngineMemoryInspector::OnMemoryDumpComplete(
base::TimeTicks requested_at,
fpromise::suspended_task task,
bool success,
memory_instrumentation::mojom::GlobalMemoryDumpPtr raw_dump) {
DCHECK(!dump_results_);
dump_results_ = std::make_unique<inspect::Inspector>();
// If capture failed then there is no data to report.
if (!success || !raw_dump) {
task.resume_task();
return;
}
// Note the delay between requesting the dump, and it being started.
dump_results_->GetRoot().CreateDouble(
"dump_queued_duration_ms",
(raw_dump->start_time - requested_at).InMillisecondsF(),
dump_results_.get());
// Note the delay between starting the dump, and it completing.
dump_results_->GetRoot().CreateDouble(
"dump_duration_ms",
(base::TimeTicks::Now() - raw_dump->start_time).InMillisecondsF(),
dump_results_.get());
for (const auto& process_dump : raw_dump->process_dumps) {
auto node = dump_results_->GetRoot().CreateChild(
base::NumberToString(process_dump->pid));
// Include details of each process' role in the web instance.
std::ostringstream type;
type << process_dump->process_type;
static const inspect::StringReference kTypeNodeName("type");
node.CreateString(kTypeNodeName, type.str(), dump_results_.get());
const auto service_name = process_dump->service_name;
if (service_name) {
static const inspect::StringReference kServiceNodeName("service");
node.CreateString(kServiceNodeName, *service_name, dump_results_.get());
}
// Include the summary of the process' memory usage.
const auto& os_dump = process_dump->os_dump;
static const inspect::StringReference kResidentKbNodeName("resident_kb");
node.CreateUint(kResidentKbNodeName, os_dump->resident_set_kb,
dump_results_.get());
static const inspect::StringReference kPrivateKbNodeName("private_kb");
node.CreateUint(kPrivateKbNodeName, os_dump->private_footprint_kb,
dump_results_.get());
static const inspect::StringReference kSharedKbNodeName("shared_kb");
node.CreateUint(kSharedKbNodeName, os_dump->shared_footprint_kb,
dump_results_.get());
// If provided, include detail from individual allocators.
if (!process_dump->chrome_allocator_dumps.empty()) {
static const inspect::StringReference kAllocatorDumpNodeName(
"allocator_dump");
auto detail_node = node.CreateChild(kAllocatorDumpNodeName);
for (auto& it : process_dump->chrome_allocator_dumps) {
dump_results_->emplace(NodeFromAllocatorMemDump(
dump_results_.get(), &detail_node, it.first, it.second.get()));
}
dump_results_->emplace(std::move(detail_node));
}
dump_results_->emplace(std::move(node));
}
task.resume_task();
}
Codebase Browser
chromium