graph_unittest.cc 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223
  1. // Copyright 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "services/resource_coordinator/memory_instrumentation/graph.h"
  5. #include "base/test/mock_callback.h"
  6. #include "testing/gtest/include/gtest/gtest.h"
  7. namespace memory_instrumentation {
  8. namespace {
  9. using base::trace_event::MemoryAllocatorDumpGuid;
  10. using Node = memory_instrumentation::GlobalDumpGraph::Node;
  11. using Process = memory_instrumentation::GlobalDumpGraph::Process;
  12. const MemoryAllocatorDumpGuid kEmptyGuid;
  13. } // namespace
  14. TEST(GlobalDumpGraphTest, CreateContainerForProcess) {
  15. GlobalDumpGraph global_dump_graph;
  16. Process* dump = global_dump_graph.CreateGraphForProcess(10);
  17. ASSERT_NE(dump, nullptr);
  18. auto* map = global_dump_graph.process_dump_graphs().find(10)->second.get();
  19. ASSERT_EQ(dump, map);
  20. }
  21. TEST(GlobalDumpGraphTest, AddNodeOwnershipEdge) {
  22. GlobalDumpGraph global_dump_graph;
  23. Node owner(global_dump_graph.shared_memory_graph(), nullptr);
  24. Node owned(global_dump_graph.shared_memory_graph(), nullptr);
  25. global_dump_graph.AddNodeOwnershipEdge(&owner, &owned, 1);
  26. auto& edges = global_dump_graph.edges();
  27. ASSERT_NE(edges.begin(), edges.end());
  28. auto& edge = *edges.begin();
  29. ASSERT_EQ(edge.source(), &owner);
  30. ASSERT_EQ(edge.target(), &owned);
  31. ASSERT_EQ(edge.priority(), 1);
  32. }
  33. TEST(GlobalDumpGraphTest, VisitInDepthFirstPostOrder) {
  34. GlobalDumpGraph graph;
  35. Process* process_1 = graph.CreateGraphForProcess(1);
  36. Process* process_2 = graph.CreateGraphForProcess(2);
  37. Node* c1 = process_1->CreateNode(kEmptyGuid, "c1", false);
  38. Node* c2 = process_1->CreateNode(kEmptyGuid, "c2", false);
  39. Node* c2_c1 = process_1->CreateNode(kEmptyGuid, "c2/c1", false);
  40. Node* c2_c2 = process_1->CreateNode(kEmptyGuid, "c2/c2", false);
  41. Node* c3 = process_2->CreateNode(kEmptyGuid, "c3", false);
  42. Node* c3_c1 = process_2->CreateNode(kEmptyGuid, "c3/c1", false);
  43. Node* c3_c2 = process_2->CreateNode(kEmptyGuid, "c3/c2", false);
  44. // |c3_c2| owns |c2_c2|.
  45. graph.AddNodeOwnershipEdge(c3_c2, c2_c2, 1);
  46. // This method should always call owners and then children before the node
  47. // itself.
  48. auto iterator = graph.VisitInDepthFirstPostOrder();
  49. ASSERT_EQ(iterator.next(), graph.shared_memory_graph()->root());
  50. ASSERT_EQ(iterator.next(), c1);
  51. ASSERT_EQ(iterator.next(), c2_c1);
  52. ASSERT_EQ(iterator.next(), c3_c2);
  53. ASSERT_EQ(iterator.next(), c2_c2);
  54. ASSERT_EQ(iterator.next(), c2);
  55. ASSERT_EQ(iterator.next(), process_1->root());
  56. ASSERT_EQ(iterator.next(), c3_c1);
  57. ASSERT_EQ(iterator.next(), c3);
  58. ASSERT_EQ(iterator.next(), process_2->root());
  59. ASSERT_EQ(iterator.next(), nullptr);
  60. }
  61. TEST(GlobalDumpGraphTest, VisitInDepthFirstPreOrder) {
  62. GlobalDumpGraph graph;
  63. Process* process_1 = graph.CreateGraphForProcess(1);
  64. Process* process_2 = graph.CreateGraphForProcess(2);
  65. Node* c1 = process_1->CreateNode(kEmptyGuid, "c1", false);
  66. Node* c2 = process_1->CreateNode(kEmptyGuid, "c2", false);
  67. Node* c2_c1 = process_1->CreateNode(kEmptyGuid, "c2/c1", false);
  68. Node* c2_c2 = process_1->CreateNode(kEmptyGuid, "c2/c2", false);
  69. Node* c3 = process_2->CreateNode(kEmptyGuid, "c3", false);
  70. Node* c3_c1 = process_2->CreateNode(kEmptyGuid, "c3/c1", false);
  71. Node* c3_c2 = process_2->CreateNode(kEmptyGuid, "c3/c2", false);
  72. // |c2_c2| owns |c3_c2|. Note this is opposite of post-order.
  73. graph.AddNodeOwnershipEdge(c2_c2, c3_c2, 1);
  74. // This method should always call owners and then children after the node
  75. // itself.
  76. auto iterator = graph.VisitInDepthFirstPreOrder();
  77. ASSERT_EQ(iterator.next(), graph.shared_memory_graph()->root());
  78. ASSERT_EQ(iterator.next(), process_1->root());
  79. ASSERT_EQ(iterator.next(), c1);
  80. ASSERT_EQ(iterator.next(), c2);
  81. ASSERT_EQ(iterator.next(), c2_c1);
  82. ASSERT_EQ(iterator.next(), process_2->root());
  83. ASSERT_EQ(iterator.next(), c3);
  84. ASSERT_EQ(iterator.next(), c3_c1);
  85. ASSERT_EQ(iterator.next(), c3_c2);
  86. ASSERT_EQ(iterator.next(), c2_c2);
  87. ASSERT_EQ(iterator.next(), nullptr);
  88. }
  89. TEST(ProcessTest, CreateAndFindNode) {
  90. GlobalDumpGraph global_dump_graph;
  91. Process graph(1, &global_dump_graph);
  92. Node* first =
  93. graph.CreateNode(MemoryAllocatorDumpGuid(1), "simple/test/1", false);
  94. Node* second =
  95. graph.CreateNode(MemoryAllocatorDumpGuid(2), "simple/test/2", false);
  96. Node* third =
  97. graph.CreateNode(MemoryAllocatorDumpGuid(3), "simple/other/1", false);
  98. Node* fourth =
  99. graph.CreateNode(MemoryAllocatorDumpGuid(4), "complex/path", false);
  100. Node* fifth = graph.CreateNode(MemoryAllocatorDumpGuid(5),
  101. "complex/path/child/1", false);
  102. ASSERT_EQ(graph.FindNode("simple/test/1"), first);
  103. ASSERT_EQ(graph.FindNode("simple/test/2"), second);
  104. ASSERT_EQ(graph.FindNode("simple/other/1"), third);
  105. ASSERT_EQ(graph.FindNode("complex/path"), fourth);
  106. ASSERT_EQ(graph.FindNode("complex/path/child/1"), fifth);
  107. auto& nodes_by_guid = global_dump_graph.nodes_by_guid();
  108. ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(1))->second, first);
  109. ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(2))->second, second);
  110. ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(3))->second, third);
  111. ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(4))->second, fourth);
  112. ASSERT_EQ(nodes_by_guid.find(MemoryAllocatorDumpGuid(5))->second, fifth);
  113. }
  114. TEST(ProcessTest, CreateNodeParent) {
  115. GlobalDumpGraph global_dump_graph;
  116. Process graph(1, &global_dump_graph);
  117. Node* parent = graph.CreateNode(MemoryAllocatorDumpGuid(1), "simple", false);
  118. Node* child =
  119. graph.CreateNode(MemoryAllocatorDumpGuid(1), "simple/child", false);
  120. ASSERT_EQ(parent->parent(), graph.root());
  121. ASSERT_EQ(child->parent(), parent);
  122. }
  123. TEST(ProcessTest, WeakAndExplicit) {
  124. GlobalDumpGraph global_dump_graph;
  125. Process graph(1, &global_dump_graph);
  126. Node* first =
  127. graph.CreateNode(MemoryAllocatorDumpGuid(1), "simple/test/1", true);
  128. Node* second =
  129. graph.CreateNode(MemoryAllocatorDumpGuid(2), "simple/test/2", false);
  130. ASSERT_TRUE(first->is_weak());
  131. ASSERT_FALSE(second->is_weak());
  132. ASSERT_TRUE(first->is_explicit());
  133. ASSERT_TRUE(second->is_explicit());
  134. Node* parent = graph.FindNode("simple/test");
  135. ASSERT_NE(parent, nullptr);
  136. ASSERT_FALSE(parent->is_weak());
  137. ASSERT_FALSE(parent->is_explicit());
  138. Node* grandparent = graph.FindNode("simple");
  139. ASSERT_NE(grandparent, nullptr);
  140. ASSERT_FALSE(grandparent->is_weak());
  141. ASSERT_FALSE(grandparent->is_explicit());
  142. }
  143. TEST(NodeTest, GetChild) {
  144. GlobalDumpGraph global_dump_graph;
  145. Node node(global_dump_graph.shared_memory_graph(), nullptr);
  146. ASSERT_EQ(node.GetChild("test"), nullptr);
  147. Node child(global_dump_graph.shared_memory_graph(), &node);
  148. node.InsertChild("child", &child);
  149. ASSERT_EQ(node.GetChild("child"), &child);
  150. }
  151. TEST(NodeTest, InsertChild) {
  152. GlobalDumpGraph global_dump_graph;
  153. Node node(global_dump_graph.shared_memory_graph(), nullptr);
  154. ASSERT_EQ(node.GetChild("test"), nullptr);
  155. Node child(global_dump_graph.shared_memory_graph(), &node);
  156. node.InsertChild("child", &child);
  157. ASSERT_EQ(node.GetChild("child"), &child);
  158. }
  159. TEST(NodeTest, AddEntry) {
  160. GlobalDumpGraph global_dump_graph;
  161. Node node(global_dump_graph.shared_memory_graph(), nullptr);
  162. node.AddEntry("scalar", Node::Entry::ScalarUnits::kBytes, 100ul);
  163. ASSERT_EQ(node.entries()->size(), 1ul);
  164. node.AddEntry("string", "data");
  165. ASSERT_EQ(node.entries()->size(), 2ul);
  166. auto scalar = node.entries()->find("scalar");
  167. ASSERT_EQ(scalar->first, "scalar");
  168. ASSERT_EQ(scalar->second.units, Node::Entry::ScalarUnits::kBytes);
  169. ASSERT_EQ(scalar->second.value_uint64, 100ul);
  170. auto string = node.entries()->find("string");
  171. ASSERT_EQ(string->first, "string");
  172. ASSERT_EQ(string->second.value_string, "data");
  173. }
  174. } // namespace memory_instrumentation