| OLD | NEW |
|---|
| (Empty) |
| 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 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 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_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 885443002:
Roll Chrome into Mojo. (Closed)
Base URL: https://github.com/domokit/mojo.git@master