[memory-infra] Add method to override importance of ownership edges

base/trace_event/process_memory_dump.h

 // Copyright 2015 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.
 
 #ifndef BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
 #define BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
 
 #include <stddef.h>
 
 #include <unordered_map>
@@ skipping 21 matching lines @@
 namespace trace_event {
 
 class MemoryDumpSessionState;
 class TracedValue;
 
 // ProcessMemoryDump is as a strongly typed container which holds the dumps
 // produced by the MemoryDumpProvider(s) for a specific process.
 class BASE_EXPORT ProcessMemoryDump {
  public:
   struct MemoryAllocatorDumpEdge {
-    MemoryAllocatorDumpGuid source;
     MemoryAllocatorDumpGuid target;
     int importance;
     const char* type;
+    bool overridable;
   };
 
   // Maps allocator dumps absolute names (allocator_name/heap/subheap) to
   // MemoryAllocatorDump instances.
   using AllocatorDumpsMap =
       std::unordered_map<std::string, std::unique_ptr<MemoryAllocatorDump>>;
 
   using HeapDumpsMap =
       std::unordered_map<std::string, std::unique_ptr<TracedValue>>;
 
+  using AllocatorDumpEdgesMap =
+      std::unordered_map<MemoryAllocatorDumpGuid, MemoryAllocatorDumpEdge>;

[hajimehoshi, 2017/05/31 05:45:51]

Just std::map might be better (See /base/containers/README.md).

BTW, what would happen if there are two or more edges from one source to
different targets?

[ssid, 2017/06/02 23:14:46]

Done
This is not supported. A dump cannot own 2 dumps.

+
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
   // Returns the number of bytes in a kernel memory page. Some platforms may
   // have a different value for kernel page sizes from user page sizes. It is
   // important to use kernel memory page sizes for resident bytes calculation.
   // In most cases, the two are the same.
   static size_t GetSystemPageSize();
 
   // Returns the total bytes resident for a virtual address range, with given
   // |start_address| and |mapped_size|. |mapped_size| is specified in bytes. The
   // value returned is valid only if the given range is currently mmapped by the
@@ skipping 62 matching lines @@
   // semantics: |source| owns |target|, and has the effect of attributing
   // the memory usage of |target| to |source|. |importance| is optional and
   // relevant only for the cases of co-ownership, where it acts as a z-index:
   // the owner with the highest importance will be attributed |target|'s memory.
   void AddOwnershipEdge(const MemoryAllocatorDumpGuid& source,
                         const MemoryAllocatorDumpGuid& target,
                         int importance);
   void AddOwnershipEdge(const MemoryAllocatorDumpGuid& source,
                         const MemoryAllocatorDumpGuid& target);
 
-  const std::vector<MemoryAllocatorDumpEdge>& allocator_dumps_edges() const {
+  void CreateSharedMemoryOwnershipEdge(
+      const MemoryAllocatorDumpGuid& client_dump_guid,
+      const MemoryAllocatorDumpGuid& client_global_dump_guid,
+      bool is_weak,
+      int importance,
+      uint64_t shm_unguessable_token);
+
+  const AllocatorDumpEdgesMap& allocator_dumps_edges_for_testing() const {
     return allocator_dumps_edges_;
   }
 
   // Utility method to add a suballocation relationship with the following
   // semantics: |source| is suballocated from |target_node_name|.
   // This creates a child node of |target_node_name| and adds an ownership edge
   // between |source| and the new child node. As a result, the UI will not
   // account the memory of |source| in the target node.
   void AddSuballocation(const MemoryAllocatorDumpGuid& source,
                         const std::string& target_node_name);
@@ skipping 25 matching lines @@
   ProcessMemoryMaps* process_mmaps() { return &process_mmaps_; }
   bool has_process_mmaps() const { return has_process_mmaps_; }
   void set_has_process_mmaps() { has_process_mmaps_ = true; }
 
   const HeapDumpsMap& heap_dumps() const { return heap_dumps_; }
 
   const MemoryDumpArgs& dump_args() const { return dump_args_; }
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ProcessMemoryDumpTest, BackgroundModeTest);
+  FRIEND_TEST_ALL_PREFIXES(ProcessMemoryDumpTest, OverrideOwnershipEdge);
 
   MemoryAllocatorDump* AddAllocatorDumpInternal(
       std::unique_ptr<MemoryAllocatorDump> mad);
 
   MemoryAllocatorDump* GetBlackHoleMad();
 
+  void AddOverridableOwnershipEdge(const MemoryAllocatorDumpGuid& source,
+                                   const MemoryAllocatorDumpGuid& target,
+                                   int importance);
+
   ProcessMemoryTotals process_totals_;
   bool has_process_totals_;
 
   ProcessMemoryMaps process_mmaps_;
   bool has_process_mmaps_;
 
   AllocatorDumpsMap allocator_dumps_;
   HeapDumpsMap heap_dumps_;
 
   // State shared among all PMDs instances created in a given trace session.
   scoped_refptr<MemoryDumpSessionState> session_state_;
 
   // Keeps track of relationships between MemoryAllocatorDump(s).
-  std::vector<MemoryAllocatorDumpEdge> allocator_dumps_edges_;
+  AllocatorDumpEdgesMap allocator_dumps_edges_;
 
   // Level of detail of the current dump.
   const MemoryDumpArgs dump_args_;
 
   // This allocator dump is returned when an invalid dump is created in
   // background mode. The attributes of the dump are ignored and not added to
   // the trace.
   std::unique_ptr<MemoryAllocatorDump> black_hole_mad_;
 
   // When set to true, the DCHECK(s) for invalid dump creations on the
   // background mode are disabled for testing.
   static bool is_black_hole_non_fatal_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryDump);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_