OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 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 "base/profiler/cpu_profiler.h" |
| 6 |
| 7 #include <stddef.h> |
| 8 |
| 9 #include "base/debug/stack_trace.h" |
| 10 #include "base/metrics/field_trial.h" |
| 11 #include "base/strings/string_number_conversions.h" |
| 12 #include "base/threading/thread_id_name_manager.h" |
| 13 #include "base/time/time.h" |
| 14 #include "base/timer/elapsed_timer.h" |
| 15 |
| 16 namespace base { |
| 17 |
| 18 namespace { |
| 19 |
| 20 const char kMode[] = "Mode"; |
| 21 const char kInitialDelay[] = "InitialDelay"; |
| 22 const char kNumberOfBursts[] = "NumberOfBursts"; |
| 23 const char kBurstIdleTime[] = "IdleTime"; |
| 24 const char kNumberOfSamples[] = "NumberOfSamples"; |
| 25 const char kSamplingSleepTime[] = "SamplingSleepTime"; |
| 26 |
| 27 } // namespace |
| 28 |
| 29 class CpuProfiler::SamplingThread : public PlatformThread::Delegate { |
| 30 public: |
| 31 SamplingThread(CpuProfiler* cpu_profiler); |
| 32 ~SamplingThread() override; |
| 33 |
| 34 // Implementation of PlatformThread::Delegate: |
| 35 void ThreadMain() override; |
| 36 |
| 37 void Stop(); |
| 38 |
| 39 void GetSamples(); |
| 40 |
| 41 private: |
| 42 CpuProfiler* cpu_profiler_; |
| 43 |
| 44 bool thread_running_; |
| 45 |
| 46 base::WaitableEvent waitable_event_; |
| 47 |
| 48 DISALLOW_COPY_AND_ASSIGN(SamplingThread); |
| 49 }; |
| 50 |
| 51 CpuProfiler::SamplingThread::SamplingThread(CpuProfiler* cpu_profiler) |
| 52 : cpu_profiler_(cpu_profiler), |
| 53 thread_running_(false), |
| 54 waitable_event_(false, false) { |
| 55 } |
| 56 |
| 57 CpuProfiler::SamplingThread::~SamplingThread() {} |
| 58 |
| 59 void CpuProfiler::SamplingThread::ThreadMain() { |
| 60 PlatformThread::SetName("Chrome_CPUProfilerThread"); |
| 61 thread_running_ = true; |
| 62 |
| 63 if (cpu_profiler_->GetStringParam(kMode) == "bursts") { |
| 64 int64 initial_delay = cpu_profiler_->GetInt64Param(kInitialDelay); |
| 65 int number_of_bursts = cpu_profiler_->GetIntParam(kNumberOfBursts); |
| 66 int64 burst_idle_time = cpu_profiler_->GetInt64Param(kBurstIdleTime); |
| 67 int number_of_samples = cpu_profiler_->GetIntParam(kNumberOfSamples); |
| 68 int64 sampling_sleep_time = |
| 69 cpu_profiler_->GetInt64Param(kSamplingSleepTime); |
| 70 |
| 71 if (waitable_event_.TimedWait(TimeDelta::FromMicroseconds(initial_delay))) |
| 72 return; |
| 73 for (int i = 0; i < number_of_bursts; ++i) { |
| 74 int64 delta = 0; |
| 75 for (int j = 0; ; ++j) { |
| 76 base::ElapsedTimer time; |
| 77 GetSamples(); |
| 78 delta = time.Elapsed().InMicroseconds(); |
| 79 if (j == (number_of_samples - 1)) |
| 80 break; |
| 81 if (delta < sampling_sleep_time) { |
| 82 if (waitable_event_.TimedWait( |
| 83 TimeDelta::FromMicroseconds(sampling_sleep_time - delta))) |
| 84 return; |
| 85 } else { |
| 86 if (waitable_event_.TimedWait( |
| 87 TimeDelta::FromMicroseconds(sampling_sleep_time))) |
| 88 return; |
| 89 } |
| 90 } |
| 91 if (waitable_event_.TimedWait( |
| 92 TimeDelta::FromMicroseconds(burst_idle_time - delta))) |
| 93 return; |
| 94 } |
| 95 } |
| 96 } |
| 97 |
| 98 void CpuProfiler::SamplingThread::Stop() { |
| 99 waitable_event_.Signal(); |
| 100 } |
| 101 |
| 102 void CpuProfiler::SamplingThread::GetSamples() { |
| 103 cpu_profiler_->OnTimer(); |
| 104 } |
| 105 |
| 106 void CpuProfiler::SamplingThreadDeleter::operator()( |
| 107 SamplingThread* thread) const { |
| 108 delete thread; |
| 109 } |
| 110 |
| 111 void CpuProfiler::Initialize(const std::map<std::string, std::string>* params) { |
| 112 if (!CpuProfiler::IsPlatformSupported()) |
| 113 return; |
| 114 |
| 115 std::map<std::string, std::string> default_params; |
| 116 default_params[kMode] = "bursts"; |
| 117 default_params[kInitialDelay] = "0"; // 0 sec |
| 118 default_params[kNumberOfBursts] = "1"; |
| 119 default_params[kBurstIdleTime] = "10000000"; // 10 sec |
| 120 default_params[kNumberOfSamples] = "300"; |
| 121 default_params[kSamplingSleepTime] = "100000"; // 100 ms |
| 122 |
| 123 if (!params) |
| 124 SetParams(default_params); |
| 125 else |
| 126 SetParams(*params); |
| 127 |
| 128 sampling_thread_.reset(new SamplingThread(this)); |
| 129 if (!PlatformThread::Create(0, sampling_thread_.get(), |
| 130 &sampling_thread_handle_)) { |
| 131 LOG(ERROR) << "failed to create thread"; |
| 132 } |
| 133 } |
| 134 |
| 135 void CpuProfiler::Stop() { |
| 136 if (sampling_thread_) |
| 137 sampling_thread_->Stop(); |
| 138 } |
| 139 |
| 140 |
| 141 std::string CpuProfiler::GetStringParam(const std::string& key) const{ |
| 142 const auto entry = params_.find(key); |
| 143 if (entry != params_.end()) { |
| 144 return entry->second; |
| 145 } |
| 146 return ""; |
| 147 } |
| 148 |
| 149 int CpuProfiler::GetIntParam(const std::string& key) const { |
| 150 const auto entry = params_.find(key); |
| 151 if (entry != params_.end()) { |
| 152 int output; |
| 153 if (base::StringToInt(entry->second, &output)) |
| 154 return output; |
| 155 } |
| 156 return 0; |
| 157 } |
| 158 |
| 159 int64 CpuProfiler::GetInt64Param(const std::string& key) const { |
| 160 const auto entry = params_.find(key); |
| 161 if (entry != params_.end()) { |
| 162 int64 output; |
| 163 if (base::StringToInt64(entry->second, &output)) |
| 164 return output; |
| 165 } |
| 166 return 0; |
| 167 } |
| 168 |
| 169 void CpuProfiler::SetParams( |
| 170 const std::map<std::string, std::string>& params) { |
| 171 params_ = params; |
| 172 } |
| 173 |
| 174 } // namespace base |
OLD | NEW |