base/trace_event/trace_event_memory.h

   1 // Copyright 2013 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_TRACE_EVENT_MEMORY_H_
   6 #define BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_H_
   7
   8 #include "base/base_export.h"
   9 #include "base/gtest_prod_util.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "base/timer/timer.h"
  13 #include "base/trace_event/trace_event_impl.h"
  14
  15 // TODO(jamescook): Windows support for memory tracing.
  16 #if !defined(NO_TCMALLOC) && !defined(OS_NACL) && \
  17     (defined(OS_LINUX) || defined(OS_ANDROID))
  18 #define TCMALLOC_TRACE_MEMORY_SUPPORTED 1
  19 #endif
  20
  21 namespace base {
  22
  23 class MessageLoopProxy;
  24
  25 namespace trace_event {
  26
  27 // Watches for chrome://tracing to be enabled or disabled. When tracing is
  28 // enabled, also enables tcmalloc heap profiling. This class is the preferred
  29 // way to turn trace-base heap memory profiling on and off.
  30 class BASE_EXPORT TraceMemoryController
  31     : public TraceLog::EnabledStateObserver {
  32  public:
  33   typedef int (*StackGeneratorFunction)(int skip_count, void** stack);
  34   typedef void (*HeapProfilerStartFunction)(StackGeneratorFunction callback);
  35   typedef void (*HeapProfilerStopFunction)();
  36   typedef char* (*GetHeapProfileFunction)();
  37
  38   // |message_loop_proxy| must be a proxy to the primary thread for the client
  39   // process, e.g. the UI thread in a browser. The function pointers must be
  40   // pointers to tcmalloc heap profiling functions; by avoiding direct calls to
  41   // these functions we avoid a dependency on third_party/tcmalloc from base.
  42   TraceMemoryController(
  43       scoped_refptr<MessageLoopProxy> message_loop_proxy,
  44       HeapProfilerStartFunction heap_profiler_start_function,
  45       HeapProfilerStopFunction heap_profiler_stop_function,
  46       GetHeapProfileFunction get_heap_profile_function);
  47   virtual ~TraceMemoryController();
  48
  49   // base::trace_event::TraceLog::EnabledStateChangedObserver overrides:
  50   void OnTraceLogEnabled() override;
  51   void OnTraceLogDisabled() override;
  52
  53   // Starts heap memory profiling.
  54   void StartProfiling();
  55
  56   // Captures a heap profile.
  57   void DumpMemoryProfile();
  58
  59   // If memory tracing is enabled, dumps a memory profile to the tracing system.
  60   void StopProfiling();
  61
  62  private:
  63   FRIEND_TEST_ALL_PREFIXES(TraceMemoryTest, TraceMemoryController);
  64
  65   bool IsTimerRunningForTest() const;
  66
  67   // Ensures the observer starts and stops tracing on the primary thread.
  68   scoped_refptr<MessageLoopProxy> message_loop_proxy_;
  69
  70   // Pointers to tcmalloc heap profiling functions. Allows this class to use
  71   // tcmalloc functions without introducing a dependency from base to tcmalloc.
  72   HeapProfilerStartFunction heap_profiler_start_function_;
  73   HeapProfilerStopFunction heap_profiler_stop_function_;
  74   GetHeapProfileFunction get_heap_profile_function_;
  75
  76   // Timer to schedule memory profile dumps.
  77   RepeatingTimer<TraceMemoryController> dump_timer_;
  78
  79   WeakPtrFactory<TraceMemoryController> weak_factory_;
  80
  81   DISALLOW_COPY_AND_ASSIGN(TraceMemoryController);
  82 };
  83
  84 //////////////////////////////////////////////////////////////////////////////
  85
  86 // A scoped context for memory tracing. Pushes the name onto a stack for
  87 // recording by tcmalloc heap profiling.
  88 class BASE_EXPORT ScopedTraceMemory {
  89  public:
  90   struct ScopeData {
  91     const char* category;
  92     const char* name;
  93   };
  94
  95   // Memory for |category| and |name| must be static, for example, literal
  96   // strings in a TRACE_EVENT macro.
  97   ScopedTraceMemory(const char* category, const char* name) {
  98     if (!enabled_)
  99       return;
 100     Initialize(category, name);
 101   }
 102   ~ScopedTraceMemory() {
 103     if (!enabled_)
 104       return;
 105     Destroy();
 106   }
 107
 108   // Enables the storing of trace names on a per-thread stack.
 109   static void set_enabled(bool enabled) { enabled_ = enabled; }
 110
 111   // Testing interface:
 112   static void InitForTest();
 113   static void CleanupForTest();
 114   static int GetStackDepthForTest();
 115   static ScopeData GetScopeDataForTest(int stack_index);
 116
 117  private:
 118   void Initialize(const char* category, const char* name);
 119   void Destroy();
 120
 121   static bool enabled_;
 122   DISALLOW_COPY_AND_ASSIGN(ScopedTraceMemory);
 123 };
 124
 125 //////////////////////////////////////////////////////////////////////////////
 126
 127 // Converts tcmalloc's heap profiler data with pseudo-stacks in |input| to
 128 // trace event compatible JSON and appends to |output|. Visible for testing.
 129 BASE_EXPORT void AppendHeapProfileAsTraceFormat(const char* input,
 130                                                 std::string* output);
 131
 132 // Converts the first |line| of heap profiler data, which contains totals for
 133 // all allocations in a special format, into trace event compatible JSON and
 134 // appends to |output|. Visible for testing.
 135 BASE_EXPORT void AppendHeapProfileTotalsAsTraceFormat(const std::string& line,
 136                                                       std::string* output);
 137
 138 // Converts a single |line| of heap profiler data into trace event compatible
 139 // JSON and appends to |output|. Returns true if the line was valid and has a
 140 // non-zero number of current allocations. Visible for testing.
 141 BASE_EXPORT bool AppendHeapProfileLineAsTraceFormat(const std::string& line,
 142                                                     std::string* output);
 143
 144 // Returns a pointer to a string given its hexadecimal address in |hex_address|.
 145 // Handles both 32-bit and 64-bit addresses. Returns "null" for null pointers
 146 // and "error" if |address| could not be parsed. Visible for testing.
 147 BASE_EXPORT const char* StringFromHexAddress(const std::string& hex_address);
 148
 149 }  // namespace trace_event
 150 }  // namespace base
 151
 152 // Make local variables with unique names based on the line number. Note that
 153 // the extra level of redirection is needed.
 154 #define INTERNAL_TRACE_MEMORY_ID3(line) trace_memory_unique_##line
 155 #define INTERNAL_TRACE_MEMORY_ID2(line) INTERNAL_TRACE_MEMORY_ID3(line)
 156 #define INTERNAL_TRACE_MEMORY_ID INTERNAL_TRACE_MEMORY_ID2(__LINE__)
 157
 158 // This is the core macro that adds a scope to each TRACE_EVENT location.
 159 // It generates a unique local variable name using the macros above.
 160 #if defined(TCMALLOC_TRACE_MEMORY_SUPPORTED)
 161 #define INTERNAL_TRACE_MEMORY(category, name) \
 162   base::trace_event::ScopedTraceMemory INTERNAL_TRACE_MEMORY_ID(category, name);
 163 #else
 164 #define INTERNAL_TRACE_MEMORY(category, name)
 165 #endif  // defined(TRACE_MEMORY_SUPPORTED)
 166
 167 // A special trace name that allows us to ignore memory allocations inside
 168 // the memory dump system itself. The allocations are recorded, but the
 169 // visualizer skips them. Must match the value in heap.js.
 170 #define TRACE_MEMORY_IGNORE "trace-memory-ignore"
 171
 172 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_H_