base/trace_event/process_memory_dump.h

   1 // Copyright 2015 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
   5 #ifndef BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
   6 #define BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
   7
   8 #include <vector>
   9
  10 #include "base/base_export.h"
  11 #include "base/containers/hash_tables.h"
  12 #include "base/containers/small_map.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_vector.h"
  15 #include "base/trace_event/memory_allocator_dump.h"
  16 #include "base/trace_event/memory_allocator_dump_guid.h"
  17 #include "base/trace_event/memory_dump_session_state.h"
  18 #include "base/trace_event/process_memory_maps.h"
  19 #include "base/trace_event/process_memory_totals.h"
  20
  21 namespace base {
  22 namespace trace_event {
  23
  24 class ConvertableToTraceFormat;
  25 class MemoryDumpManager;
  26 class MemoryDumpSessionState;
  27
  28 // ProcessMemoryDump is as a strongly typed container which enforces the data
  29 // model for each memory dump and holds the dumps produced by the
  30 // MemoryDumpProvider(s) for a specific process.
  31 // At trace generation time (i.e. when AsValue() is called), ProcessMemoryDump
  32 // will compose a key-value dictionary of the various dumps obtained at trace
  33 // dump point time.
  34 class BASE_EXPORT ProcessMemoryDump {
  35  public:
  36   struct MemoryAllocatorDumpEdge {
  37     MemoryAllocatorDumpGuid source;
  38     MemoryAllocatorDumpGuid target;
  39     int importance;
  40     const char* type;
  41   };
  42
  43   // Maps allocator dumps absolute names (allocator_name/heap/subheap) to
  44   // MemoryAllocatorDump instances.
  45   using AllocatorDumpsMap =
  46       SmallMap<hash_map<std::string, MemoryAllocatorDump*>>;
  47
  48   ProcessMemoryDump(const scoped_refptr<MemoryDumpSessionState>& session_state);
  49   ~ProcessMemoryDump();
  50
  51   // Creates a new MemoryAllocatorDump with the given name and returns the
  52   // empty object back to the caller.
  53   // Arguments:
  54   //   absolute_name: a name that uniquely identifies allocator dumps produced
  55   //       by this provider. It is possible to specify nesting by using a
  56   //       path-like string (e.g., v8/isolate1/heap1, v8/isolate1/heap2).
  57   //       Leading or trailing slashes are not allowed.
  58   //   guid: an optional identifier, unique among all processes within the
  59   //       scope of a global dump. This is only relevant when using
  60   //       AddOwnershipEdge() to express memory sharing. If omitted,
  61   //       it will be automatically generated.
  62   // ProcessMemoryDump handles the memory ownership of its MemoryAllocatorDumps.
  63   MemoryAllocatorDump* CreateAllocatorDump(const std::string& absolute_name);
  64   MemoryAllocatorDump* CreateAllocatorDump(const std::string& absolute_name,
  65                                            const MemoryAllocatorDumpGuid& guid);
  66
  67   // Looks up a MemoryAllocatorDump given its allocator and heap names, or
  68   // nullptr if not found.
  69   MemoryAllocatorDump* GetAllocatorDump(const std::string& absolute_name) const;
  70
  71   // Creates a shared MemoryAllocatorDump, to express cross-process sharing.
  72   // Shared allocator dumps are allowed to have duplicate guids within the
  73   // global scope, in order to reference the same dump from multiple processes.
  74   // See the design doc goo.gl/keU6Bf for reference usage patterns.
  75   MemoryAllocatorDump* CreateSharedGlobalAllocatorDump(
  76       const MemoryAllocatorDumpGuid& guid);
  77
  78   // Looks up a shared MemoryAllocatorDump given its guid.
  79   MemoryAllocatorDump* GetSharedGlobalAllocatorDump(
  80       const MemoryAllocatorDumpGuid& guid) const;
  81
  82   // Returns the map of the MemoryAllocatorDumps added to this dump.
  83   const AllocatorDumpsMap& allocator_dumps() const { return allocator_dumps_; }
  84
  85   // Adds an ownership relationship between two MemoryAllocatorDump(s) with the
  86   // semantics: |source| owns |target|, and has the effect of attributing
  87   // the memory usage of |target| to |source|. |importance| is optional and
  88   // relevant only for the cases of co-ownership, where it acts as a z-index:
  89   // the owner with the highest importance will be attributed |target|'s memory.
  90   void AddOwnershipEdge(const MemoryAllocatorDumpGuid& source,
  91                         const MemoryAllocatorDumpGuid& target,
  92                         int importance);
  93   void AddOwnershipEdge(const MemoryAllocatorDumpGuid& source,
  94                         const MemoryAllocatorDumpGuid& target);
  95
  96   const std::vector<MemoryAllocatorDumpEdge>& allocator_dumps_edges() const {
  97     return allocator_dumps_edges_;
  98   }
  99
 100   // Utility method to add a suballocation relationship with the following
 101   // semantics: |source| is suballocated from |target_node_name|.
 102   // This creates a child node of |target_node_name| and adds an ownership edge
 103   // between |source| and the new child node. As a result, the UI will not
 104   // account the memory of |source| in the target node.
 105   void AddSuballocation(const MemoryAllocatorDumpGuid& source,
 106                         const std::string& target_node_name);
 107
 108   const scoped_refptr<MemoryDumpSessionState>& session_state() const {
 109     return session_state_;
 110   }
 111
 112   // Removes all the MemoryAllocatorDump(s) contained in this instance. This
 113   // ProcessMemoryDump can be safely reused as if it was new once this returns.
 114   void Clear();
 115
 116   // Merges all MemoryAllocatorDump(s) contained in |other| inside this
 117   // ProcessMemoryDump, transferring their ownership to this instance.
 118   // |other| will be an empty ProcessMemoryDump after this method returns.
 119   // This is to allow dump providers to pre-populate ProcessMemoryDump instances
 120   // and later move their contents into the ProcessMemoryDump passed as argument
 121   // of the MemoryDumpProvider::OnMemoryDump(ProcessMemoryDump*) callback.
 122   void TakeAllDumpsFrom(ProcessMemoryDump* other);
 123
 124   // Called at trace generation time to populate the TracedValue.
 125   void AsValueInto(TracedValue* value) const;
 126
 127   ProcessMemoryTotals* process_totals() { return &process_totals_; }
 128   bool has_process_totals() const { return has_process_totals_; }
 129   void set_has_process_totals() { has_process_totals_ = true; }
 130
 131   ProcessMemoryMaps* process_mmaps() { return &process_mmaps_; }
 132   bool has_process_mmaps() const { return has_process_mmaps_; }
 133   void set_has_process_mmaps() { has_process_mmaps_ = true; }
 134
 135  private:
 136   void AddAllocatorDumpInternal(MemoryAllocatorDump* mad);
 137
 138   ProcessMemoryTotals process_totals_;
 139   bool has_process_totals_;
 140
 141   ProcessMemoryMaps process_mmaps_;
 142   bool has_process_mmaps_;
 143
 144   AllocatorDumpsMap allocator_dumps_;
 145
 146   // ProcessMemoryDump handles the memory ownership of all its belongings.
 147   ScopedVector<MemoryAllocatorDump> allocator_dumps_storage_;
 148
 149   // State shared among all PMDs instances created in a given trace session.
 150   scoped_refptr<MemoryDumpSessionState> session_state_;
 151
 152   // Keeps track of relationships between MemoryAllocatorDump(s).
 153   std::vector<MemoryAllocatorDumpEdge> allocator_dumps_edges_;
 154
 155   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryDump);
 156 };
 157
 158 }  // namespace trace_event
 159 }  // namespace base
 160
 161 #endif  // BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_