fuchsia_web/webengine/browser/web_engine_memory_inspector.cc - chromium/src - Git at Google

 // 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 absl::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();
 }
	// 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 absl::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();
	}