chrome/common/profiling.cc

   1 // Copyright (c) 2012 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 #include "chrome/common/profiling.h"
   6
   7 #include "base/at_exit.h"
   8 #include "base/bind.h"
   9 #include "base/command_line.h"
  10 #include "base/debug/profiler.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/threading/thread.h"
  15 #include "chrome/common/chrome_switches.h"
  16 #include "gin/public/debug.h"
  17 #include "v8/include/v8.h"
  18
  19 namespace {
  20
  21 base::debug::AddDynamicSymbol add_dynamic_symbol_func = NULL;
  22 base::debug::MoveDynamicSymbol move_dynamic_symbol_func = NULL;
  23
  24 void JitCodeEventHandler(const v8::JitCodeEvent* event) {
  25   DCHECK_NE(static_cast<base::debug::AddDynamicSymbol>(NULL),
  26             add_dynamic_symbol_func);
  27   DCHECK_NE(static_cast<base::debug::MoveDynamicSymbol>(NULL),
  28             move_dynamic_symbol_func);
  29
  30   switch (event->type) {
  31     case v8::JitCodeEvent::CODE_ADDED:
  32       add_dynamic_symbol_func(event->code_start, event->code_len,
  33                               event->name.str, event->name.len);
  34       break;
  35
  36     case v8::JitCodeEvent::CODE_MOVED:
  37       move_dynamic_symbol_func(event->code_start, event->new_code_start);
  38       break;
  39
  40     default:
  41       break;
  42   }
  43 }
  44
  45 std::string GetProfileName() {
  46   static const char kDefaultProfileName[] = "chrome-profile-{type}-{pid}";
  47   CR_DEFINE_STATIC_LOCAL(std::string, profile_name, ());
  48
  49   if (profile_name.empty()) {
  50     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
  51     if (command_line.HasSwitch(switches::kProfilingFile))
  52       profile_name = command_line.GetSwitchValueASCII(switches::kProfilingFile);
  53     else
  54       profile_name = std::string(kDefaultProfileName);
  55     std::string process_type =
  56         command_line.GetSwitchValueASCII(switches::kProcessType);
  57     std::string type = process_type.empty() ?
  58         std::string("browser") : std::string(process_type);
  59     ReplaceSubstringsAfterOffset(&profile_name, 0, "{type}", type.c_str());
  60   }
  61   return profile_name;
  62 }
  63
  64 void FlushProfilingData(base::Thread* thread) {
  65   static const int kProfilingFlushSeconds = 10;
  66
  67   if (!Profiling::BeingProfiled())
  68     return;
  69
  70   base::debug::FlushProfiling();
  71   static int flush_seconds;
  72   if (!flush_seconds) {
  73     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
  74     std::string profiling_flush =
  75         command_line.GetSwitchValueASCII(switches::kProfilingFlush);
  76     if (!profiling_flush.empty()) {
  77       flush_seconds = atoi(profiling_flush.c_str());
  78       DCHECK(flush_seconds > 0);
  79     } else {
  80       flush_seconds = kProfilingFlushSeconds;
  81     }
  82   }
  83   thread->message_loop()->PostDelayedTask(
  84       FROM_HERE,
  85       base::Bind(&FlushProfilingData, thread),
  86       base::TimeDelta::FromSeconds(flush_seconds));
  87 }
  88
  89 class ProfilingThreadControl {
  90  public:
  91   ProfilingThreadControl() : thread_(NULL) {}
  92
  93   void Start() {
  94     base::AutoLock locked(lock_);
  95
  96     if (thread_ && thread_->IsRunning())
  97       return;
  98     thread_ = new base::Thread("Profiling_Flush");
  99     thread_->Start();
 100     thread_->message_loop()->PostTask(
 101         FROM_HERE, base::Bind(&FlushProfilingData, thread_));
 102   }
 103
 104   void Stop() {
 105     base::AutoLock locked(lock_);
 106
 107     if (!thread_ || !thread_->IsRunning())
 108       return;
 109     thread_->Stop();
 110     delete thread_;
 111     thread_ = NULL;
 112   }
 113
 114  private:
 115   base::Thread* thread_;
 116   base::Lock lock_;
 117
 118   DISALLOW_COPY_AND_ASSIGN(ProfilingThreadControl);
 119 };
 120
 121 base::LazyInstance<ProfilingThreadControl>::Leaky
 122     g_flush_thread_control = LAZY_INSTANCE_INITIALIZER;
 123
 124 } // namespace
 125
 126 // static
 127 void Profiling::ProcessStarted() {
 128   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 129   std::string process_type =
 130       command_line.GetSwitchValueASCII(switches::kProcessType);
 131
 132   // Establish the V8 profiling hooks if we're an instrumented binary.
 133   if (base::debug::IsBinaryInstrumented()) {
 134     base::debug::ReturnAddressLocationResolver resolve_func =
 135         base::debug::GetProfilerReturnAddrResolutionFunc();
 136
 137     if (resolve_func != NULL) {
 138       v8::V8::SetReturnAddressLocationResolver(resolve_func);
 139     }
 140
 141     // Set up the JIT code entry handler and the symbol callbacks if the
 142     // profiler supplies them.
 143     // TODO(siggi): Maybe add a switch or an environment variable to turn off
 144     //     V8 profiling?
 145     base::debug::DynamicFunctionEntryHook entry_hook_func =
 146         base::debug::GetProfilerDynamicFunctionEntryHookFunc();
 147     add_dynamic_symbol_func = base::debug::GetProfilerAddDynamicSymbolFunc();
 148     move_dynamic_symbol_func = base::debug::GetProfilerMoveDynamicSymbolFunc();
 149
 150     if (entry_hook_func != NULL &&
 151         add_dynamic_symbol_func != NULL &&
 152         move_dynamic_symbol_func != NULL) {
 153       gin::Debug::SetFunctionEntryHook(entry_hook_func);
 154       gin::Debug::SetJitCodeEventHandler(&JitCodeEventHandler);
 155     }
 156   }
 157
 158   if (command_line.HasSwitch(switches::kProfilingAtStart)) {
 159     std::string process_type_to_start =
 160         command_line.GetSwitchValueASCII(switches::kProfilingAtStart);
 161     if (process_type == process_type_to_start)
 162       Start();
 163   }
 164 }
 165
 166 // static
 167 void Profiling::Start() {
 168   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 169   bool flush = command_line.HasSwitch(switches::kProfilingFlush);
 170   base::debug::StartProfiling(GetProfileName());
 171
 172   // Schedule profile data flushing for single process because it doesn't
 173   // get written out correctly on exit.
 174   if (flush)
 175     g_flush_thread_control.Get().Start();
 176 }
 177
 178 // static
 179 void Profiling::Stop() {
 180   g_flush_thread_control.Get().Stop();
 181   base::debug::StopProfiling();
 182 }
 183
 184 // static
 185 bool Profiling::BeingProfiled() {
 186   return base::debug::BeingProfiled();
 187 }
 188
 189 // static
 190 void Profiling::Toggle() {
 191   if (BeingProfiled())
 192     Stop();
 193   else
 194     Start();
 195 }