services/resource_coordinator/memory_instrumentation/graph_unittest.cc

// Copyright 2017 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 "services/resource_coordinator/memory_instrumentation/graph.h"

#include "base/test/mock_callback.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace memory_instrumentation {

namespace {

using base::trace_event::MemoryAllocatorDumpGuid;
using Node = memory_instrumentation::GlobalDumpGraph::Node;
using Process = memory_instrumentation::GlobalDumpGraph::Process;

const MemoryAllocatorDumpGuid kEmptyGuid;

}  // namespace

TEST(GlobalDumpGraphTest, CreateContainerForProcess) {
  GlobalDumpGraph global_dump_graph;

  Process* dump = global_dump_graph.CreateGraphForProcess(10);
  ASSERT_NE(dump, nullptr);

  auto* map = global_dump_graph.process_dump_graphs().find(10)->second.get();
  ASSERT_EQ(dump, map);
}

TEST(GlobalDumpGraphTest, AddNodeOwnershipEdge) {
  GlobalDumpGraph global_dump_graph;
  Node owner(global_dump_graph.shared_memory_graph(), nullptr);
  Node owned(global_dump_graph.shared_memory_graph(), nullptr);

  global_dump_graph.AddNodeOwnershipEdge(&owner, &owned, 1);

  auto& edges = global_dump_graph.edges();
  ASSERT_NE(edges.begin(), edges.end());

  auto& edge = *edges.begin();
  ASSERT_EQ(edge.source(), &owner);
  ASSERT_EQ(edge.target(), &owned);
  ASSERT_EQ(edge.priority(), 1);
}

TEST(GlobalDumpGraphTest, VisitInDepthFirstPostOrder) {
  GlobalDumpGraph graph;
  Process* process_1 = graph.CreateGraphForProcess(1);
  Process* process_2 = graph.CreateGraphForProcess(2);

  Node* c1 = process_1->CreateNode(kEmptyGuid, "c1", false);
  Node* c2 = process_1->CreateNode(kEmptyGuid, "c2", false);
  Node* c2_c1 = process_1->CreateNode(kEmptyGuid, "c2/c1", false);
  Node* c2_c2 = process_1->CreateNode(kEmptyGuid, "c2/c2", false);

  Node* c3 = process_2->CreateNode(kEmptyGuid, "c3", false);
  Node* c3_c1 = process_2->CreateNode(kEmptyGuid, "c3/c1", false);
  Node* c3_c2 = process_2->CreateNode(kEmptyGuid, "c3/c2", false);

  // |c3_c2| owns |c2_c2|.
  graph.AddNodeOwnershipEdge(c3_c2, c2_c2, 1);

  // This method should always call owners and then children before the node
  // itself.
  auto iterator = graph.VisitInDepthFirstPostOrder();
  ASSERT_EQ(iterator.next(), graph.shared_memory_graph()->root());
  ASSERT_EQ(iterator.next(), c1);
  ASSERT_EQ(iterator.next(), c2_c1);
  ASSERT_EQ(iterator.next(), c3_c2);
  ASSERT_EQ(iterator.next(), c2_c2);
  ASSERT_EQ(iterator.next(), c2);
  ASSERT_EQ(iterator.next(), process_1->root());
  ASSERT_EQ(iterator.next(), c3_c1);
  ASSERT_EQ(iterator.next(), c3);
  ASSERT_EQ(iterator.next(), process_2->root());
  ASSERT_EQ(iterator.next(), nullptr);
}

TEST(GlobalDumpGraphTest, VisitInDepthFirstPreOrder) {
  GlobalDumpGraph graph;
  Process* process_1 = graph.CreateGraphForProcess(1);
  Process* process_2 = graph.CreateGraphForProcess(2);

  Node* c1 = process_1->CreateNode(kEmptyGuid, "c1", false);
  Node* c2 = process_1->CreateNode(kEmptyGuid, "c2", false);
  Node* c2_c1 = process_1->CreateNode(kEmptyGuid, "c2/c1", false);
  Node* c2_c2 = process_1->CreateNode(kEmptyGuid, "c2/c2", false);

  Node* c3 = process_2->CreateNode(kEmptyGuid, "c3", false);
  Node* c3_c1 = process_2->CreateNode(kEmptyGuid, "c3/c1", false);
  Node* c3_c2 = process_2->CreateNode(kEmptyGuid, "c3/c2", false);

  // |c2_c2| owns |c3_c2|. Note this is opposite of post-order.
  graph.AddNodeOwnershipEdge(c2_c2, c3_c2, 1);

  // This method should always call owners and then children after the node
  // itself.
  auto iterator = graph.VisitInDepthFirstPreOrder();
  ASSERT_EQ(iterator.next(), graph.shared_memory_graph()->root());
  ASSERT_EQ(iterator.next(), process_1->root());
  ASSERT_EQ(iterator.next(), c1);
  ASSERT_EQ(iterator.next(), c2);
  ASSERT_EQ(iterator.next(), c2_c1);
  ASSERT_EQ(iterator.next(), process_2->root());
  ASSERT_EQ(iterator.next(), c3);
  ASSERT_EQ(iterator.next(), c3_c1);
  ASSERT_EQ(iterator.next(), c3_c2);
  ASSERT_EQ(iterator.next(), c2_c2);
  ASSERT_EQ(iterator.next(), nullptr);
}

TEST(ProcessTest, CreateAndFindNode) {
  GlobalDumpGraph global_dump_graph;
  Process graph(1, &global_dump_graph);

  Node* first =
      graph.CreateNode(MemoryAllocatorDumpGuid(1), "simple/test/1", false);
  Node* second =
      graph.CreateNode(MemoryAllocatorDumpGuid(2), "simple/test/2", false);
  Node* third =
      graph.CreateNode(MemoryAllocatorDumpGuid(3), "simple/other/1", false);
  Node* fourth =
      graph.CreateNode(MemoryAllocatorDumpGuid(4), "complex/path", false);
  Node* fifth = graph.CreateNode(MemoryAllocatorDumpGuid(5),
                                 "complex/path/child/1", false);

  ASSERT_EQ(graph.FindNode("simple/test/1"), first);
  ASSERT_EQ(graph.FindNode("simple/test/2"), second);
  ASSERT_EQ(graph.FindNode("simple/other/1"), third);
  ASSERT_EQ(graph.FindNode("complex/path"), fourth);
  ASSERT_EQ(graph.FindNode("complex/path/child/1"), fifth);

  auto& nodes_by_guid = global_dump_graph.nodes_by_guid();
  ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(1))->second, first);
  ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(2))->second, second);
  ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(3))->second, third);
  ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(4))->second, fourth);
  ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(5))->second, fifth);
}

TEST(ProcessTest, CreateNodeParent) {
  GlobalDumpGraph global_dump_graph;
  Process graph(1, &global_dump_graph);

  Node* parent = graph.CreateNode(MemoryAllocatorDumpGuid(1), "simple", false);
  Node* child =
      graph.CreateNode(MemoryAllocatorDumpGuid(1), "simple/child", false);

  ASSERT_EQ(parent->parent(), graph.root());
  ASSERT_EQ(child->parent(), parent);
}

TEST(ProcessTest, WeakAndExplicit) {
  GlobalDumpGraph global_dump_graph;
  Process graph(1, &global_dump_graph);

  Node* first =
      graph.CreateNode(MemoryAllocatorDumpGuid(1), "simple/test/1", true);
  Node* second =
      graph.CreateNode(MemoryAllocatorDumpGuid(2), "simple/test/2", false);

  ASSERT_TRUE(first->is_weak());
  ASSERT_FALSE(second->is_weak());

  ASSERT_TRUE(first->is_explicit());
  ASSERT_TRUE(second->is_explicit());

  Node* parent = graph.FindNode("simple/test");
  ASSERT_NE(parent, nullptr);
  ASSERT_FALSE(parent->is_weak());
  ASSERT_FALSE(parent->is_explicit());

  Node* grandparent = graph.FindNode("simple");
  ASSERT_NE(grandparent, nullptr);
  ASSERT_FALSE(grandparent->is_weak());
  ASSERT_FALSE(grandparent->is_explicit());
}

TEST(NodeTest, GetChild) {
  GlobalDumpGraph global_dump_graph;
  Node node(global_dump_graph.shared_memory_graph(), nullptr);

  ASSERT_EQ(node.GetChild("test"), nullptr);

  Node child(global_dump_graph.shared_memory_graph(), &node);
  node.InsertChild("child", &child);
  ASSERT_EQ(node.GetChild("child"), &child);
}

TEST(NodeTest, InsertChild) {
  GlobalDumpGraph global_dump_graph;
  Node node(global_dump_graph.shared_memory_graph(), nullptr);

  ASSERT_EQ(node.GetChild("test"), nullptr);

  Node child(global_dump_graph.shared_memory_graph(), &node);
  node.InsertChild("child", &child);
  ASSERT_EQ(node.GetChild("child"), &child);
}

TEST(NodeTest, AddEntry) {
  GlobalDumpGraph global_dump_graph;
  Node node(global_dump_graph.shared_memory_graph(), nullptr);

  node.AddEntry("scalar", Node::Entry::ScalarUnits::kBytes, 100ul);
  ASSERT_EQ(node.entries()->size(), 1ul);

  node.AddEntry("string", "data");
  ASSERT_EQ(node.entries()->size(), 2ul);

  auto scalar = node.entries()->find("scalar");
  ASSERT_EQ(scalar->first, "scalar");
  ASSERT_EQ(scalar->second.units, Node::Entry::ScalarUnits::kBytes);
  ASSERT_EQ(scalar->second.value_uint64, 100ul);

  auto string = node.entries()->find("string");
  ASSERT_EQ(string->first, "string");
  ASSERT_EQ(string->second.value_string, "data");
}

}  // namespace memory_instrumentation