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_DEBUG_TRACE_EVENT_MEMORY_H_ 6 #define BASE_DEBUG_TRACE_EVENT_MEMORY_H_ 7 8 #include "base/base_export.h" 9 #include "base/debug/trace_event_impl.h" 10 #include "base/gtest_prod_util.h" 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/weak_ptr.h" 13 #include "base/timer/timer.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 debug { 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::debug::TraceLog::EnabledStateChangedObserver overrides: 50 virtual void OnTraceLogEnabled() OVERRIDE; 51 virtual 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. ScopedTraceMemory(const char * category,const char * name)97 ScopedTraceMemory(const char* category, const char* name) { 98 if (!enabled_) 99 return; 100 Initialize(category, name); 101 } ~ScopedTraceMemory()102 ~ScopedTraceMemory() { 103 if (!enabled_) 104 return; 105 Destroy(); 106 } 107 108 // Enables the storing of trace names on a per-thread stack. set_enabled(bool enabled)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 debug 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::debug::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_DEBUG_TRACE_EVENT_MEMORY_H_ 173