Home | History | Annotate | Download | only in debug 
      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.
     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_
    173