chromium/third_party/perfetto/src/trace_processor/importers/memory_tracker/graph_processor.cc

/*
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "perfetto/ext/trace_processor/importers/memory_tracker/graph_processor.h"

#include <list>

namespace perfetto {
namespace trace_processor {

Edge;
Node;
Process;

namespace {

const char kSharedMemoryRootNode[] = …;
const char kSizeEntryName[] = …;
const char kEffectiveSizeEntryName[] = …;

Node::Entry::ScalarUnits EntryUnitsFromString(const std::string& units) { … }

std::optional<uint64_t> GetSizeEntryOfNode(Node* node) { … }

}  // namespace

// static
std::unique_ptr<GlobalNodeGraph> GraphProcessor::CreateMemoryGraph(
    const GraphProcessor::RawMemoryNodeMap& process_nodes) { … }

// static
void GraphProcessor::RemoveWeakNodesFromGraph(GlobalNodeGraph* global_graph) { … }

// static
void GraphProcessor::AddOverheadsAndPropagateEntries(
    GlobalNodeGraph* global_graph) { … }

// static
void GraphProcessor::CalculateSizesForGraph(GlobalNodeGraph* global_graph) { … }

// static
std::map<base::PlatformProcessId, uint64_t>
GraphProcessor::ComputeSharedFootprintFromGraph(
    const GlobalNodeGraph& global_graph) { … }

// static
void GraphProcessor::CollectAllocatorNodes(const RawProcessMemoryNode& source,
                                           GlobalNodeGraph* global_graph,
                                           Process* process_graph) { … }

// static
void GraphProcessor::AddEdges(const RawProcessMemoryNode& source,
                              GlobalNodeGraph* global_graph) { … }

// static
void GraphProcessor::MarkImplicitWeakParentsRecursively(Node* node) { … }

// static
void GraphProcessor::MarkWeakOwnersAndChildrenRecursively(
    Node* node,
    std::set<const Node*>* visited) { … }

// static
void GraphProcessor::RemoveWeakNodesRecursively(Node* node) { … }

// static
void GraphProcessor::AssignTracingOverhead(const std::string& allocator,
                                           GlobalNodeGraph* global_graph,
                                           Process* process) { … }

// static
Node::Entry GraphProcessor::AggregateNumericWithNameForNode(
    Node* node,
    const std::string& name) { … }

// static
void GraphProcessor::AggregateNumericsRecursively(Node* node) { … }

// static
void GraphProcessor::PropagateNumericsAndDiagnosticsRecursively(Node* node) { … }

// static
std::optional<uint64_t> GraphProcessor::AggregateSizeForDescendantNode(
    Node* root,
    Node* descendant) { … }

// Assumes that this function has been called on all children and owner nodes.
// static
void GraphProcessor::CalculateSizeForNode(Node* node) { … }

// Assumes that this function has been called on all children and owner nodes.
// static
void GraphProcessor::CalculateNodeSubSizes(Node* node) { … }

// static
void GraphProcessor::CalculateNodeOwnershipCoefficient(Node* node) { … }

// static
void GraphProcessor::CalculateNodeCumulativeOwnershipCoefficient(Node* node) { … }

// static
void GraphProcessor::CalculateNodeEffectiveSize(Node* node) { … }

}  // namespace trace_processor
}  // namespace perfetto