base/trace_event/trace_event_synthetic_delay.cc

   1 // Copyright 2014 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/memory/singleton.h"
   6 #include "base/trace_event/trace_event_synthetic_delay.h"
   7
   8 namespace {
   9 const int kMaxSyntheticDelays = 32;
  10 }  // namespace
  11
  12 namespace base {
  13 namespace trace_event {
  14
  15 TraceEventSyntheticDelayClock::TraceEventSyntheticDelayClock() {}
  16 TraceEventSyntheticDelayClock::~TraceEventSyntheticDelayClock() {}
  17
  18 class TraceEventSyntheticDelayRegistry : public TraceEventSyntheticDelayClock {
  19  public:
  20   static TraceEventSyntheticDelayRegistry* GetInstance();
  21
  22   TraceEventSyntheticDelay* GetOrCreateDelay(const char* name);
  23   void ResetAllDelays();
  24
  25   // TraceEventSyntheticDelayClock implementation.
  26   base::TimeTicks Now() override;
  27
  28  private:
  29   TraceEventSyntheticDelayRegistry();
  30
  31   friend struct DefaultSingletonTraits<TraceEventSyntheticDelayRegistry>;
  32
  33   Lock lock_;
  34   TraceEventSyntheticDelay delays_[kMaxSyntheticDelays];
  35   TraceEventSyntheticDelay dummy_delay_;
  36   base::subtle::Atomic32 delay_count_;
  37
  38   DISALLOW_COPY_AND_ASSIGN(TraceEventSyntheticDelayRegistry);
  39 };
  40
  41 TraceEventSyntheticDelay::TraceEventSyntheticDelay()
  42     : mode_(STATIC), begin_count_(0), trigger_count_(0), clock_(NULL) {}
  43
  44 TraceEventSyntheticDelay::~TraceEventSyntheticDelay() {}
  45
  46 TraceEventSyntheticDelay* TraceEventSyntheticDelay::Lookup(
  47     const std::string& name) {
  48   return TraceEventSyntheticDelayRegistry::GetInstance()->GetOrCreateDelay(
  49       name.c_str());
  50 }
  51
  52 void TraceEventSyntheticDelay::Initialize(
  53     const std::string& name,
  54     TraceEventSyntheticDelayClock* clock) {
  55   name_ = name;
  56   clock_ = clock;
  57 }
  58
  59 void TraceEventSyntheticDelay::SetTargetDuration(
  60     base::TimeDelta target_duration) {
  61   AutoLock lock(lock_);
  62   target_duration_ = target_duration;
  63   trigger_count_ = 0;
  64   begin_count_ = 0;
  65 }
  66
  67 void TraceEventSyntheticDelay::SetMode(Mode mode) {
  68   AutoLock lock(lock_);
  69   mode_ = mode;
  70 }
  71
  72 void TraceEventSyntheticDelay::SetClock(TraceEventSyntheticDelayClock* clock) {
  73   AutoLock lock(lock_);
  74   clock_ = clock;
  75 }
  76
  77 void TraceEventSyntheticDelay::Begin() {
  78   // Note that we check for a non-zero target duration without locking to keep
  79   // things quick for the common case when delays are disabled. Since the delay
  80   // calculation is done with a lock held, it will always be correct. The only
  81   // downside of this is that we may fail to apply some delays when the target
  82   // duration changes.
  83   ANNOTATE_BENIGN_RACE(&target_duration_, "Synthetic delay duration");
  84   if (!target_duration_.ToInternalValue())
  85     return;
  86
  87   base::TimeTicks start_time = clock_->Now();
  88   {
  89     AutoLock lock(lock_);
  90     if (++begin_count_ != 1)
  91       return;
  92     end_time_ = CalculateEndTimeLocked(start_time);
  93   }
  94 }
  95
  96 void TraceEventSyntheticDelay::BeginParallel(base::TimeTicks* out_end_time) {
  97   // See note in Begin().
  98   ANNOTATE_BENIGN_RACE(&target_duration_, "Synthetic delay duration");
  99   if (!target_duration_.ToInternalValue()) {
 100     *out_end_time = base::TimeTicks();
 101     return;
 102   }
 103
 104   base::TimeTicks start_time = clock_->Now();
 105   {
 106     AutoLock lock(lock_);
 107     *out_end_time = CalculateEndTimeLocked(start_time);
 108   }
 109 }
 110
 111 void TraceEventSyntheticDelay::End() {
 112   // See note in Begin().
 113   ANNOTATE_BENIGN_RACE(&target_duration_, "Synthetic delay duration");
 114   if (!target_duration_.ToInternalValue())
 115     return;
 116
 117   base::TimeTicks end_time;
 118   {
 119     AutoLock lock(lock_);
 120     if (!begin_count_ || --begin_count_ != 0)
 121       return;
 122     end_time = end_time_;
 123   }
 124   if (!end_time.is_null())
 125     ApplyDelay(end_time);
 126 }
 127
 128 void TraceEventSyntheticDelay::EndParallel(base::TimeTicks end_time) {
 129   if (!end_time.is_null())
 130     ApplyDelay(end_time);
 131 }
 132
 133 base::TimeTicks TraceEventSyntheticDelay::CalculateEndTimeLocked(
 134     base::TimeTicks start_time) {
 135   if (mode_ == ONE_SHOT && trigger_count_++)
 136     return base::TimeTicks();
 137   else if (mode_ == ALTERNATING && trigger_count_++ % 2)
 138     return base::TimeTicks();
 139   return start_time + target_duration_;
 140 }
 141
 142 void TraceEventSyntheticDelay::ApplyDelay(base::TimeTicks end_time) {
 143   TRACE_EVENT0("synthetic_delay", name_.c_str());
 144   while (clock_->Now() < end_time) {
 145     // Busy loop.
 146   }
 147 }
 148
 149 TraceEventSyntheticDelayRegistry*
 150 TraceEventSyntheticDelayRegistry::GetInstance() {
 151   return Singleton<
 152       TraceEventSyntheticDelayRegistry,
 153       LeakySingletonTraits<TraceEventSyntheticDelayRegistry> >::get();
 154 }
 155
 156 TraceEventSyntheticDelayRegistry::TraceEventSyntheticDelayRegistry()
 157     : delay_count_(0) {}
 158
 159 TraceEventSyntheticDelay* TraceEventSyntheticDelayRegistry::GetOrCreateDelay(
 160     const char* name) {
 161   // Try to find an existing delay first without locking to make the common case
 162   // fast.
 163   int delay_count = base::subtle::Acquire_Load(&delay_count_);
 164   for (int i = 0; i < delay_count; ++i) {
 165     if (!strcmp(name, delays_[i].name_.c_str()))
 166       return &delays_[i];
 167   }
 168
 169   AutoLock lock(lock_);
 170   delay_count = base::subtle::Acquire_Load(&delay_count_);
 171   for (int i = 0; i < delay_count; ++i) {
 172     if (!strcmp(name, delays_[i].name_.c_str()))
 173       return &delays_[i];
 174   }
 175
 176   DCHECK(delay_count < kMaxSyntheticDelays)
 177       << "must increase kMaxSyntheticDelays";
 178   if (delay_count >= kMaxSyntheticDelays)
 179     return &dummy_delay_;
 180
 181   delays_[delay_count].Initialize(std::string(name), this);
 182   base::subtle::Release_Store(&delay_count_, delay_count + 1);
 183   return &delays_[delay_count];
 184 }
 185
 186 base::TimeTicks TraceEventSyntheticDelayRegistry::Now() {
 187   return base::TimeTicks::Now();
 188 }
 189
 190 void TraceEventSyntheticDelayRegistry::ResetAllDelays() {
 191   AutoLock lock(lock_);
 192   int delay_count = base::subtle::Acquire_Load(&delay_count_);
 193   for (int i = 0; i < delay_count; ++i) {
 194     delays_[i].SetTargetDuration(base::TimeDelta());
 195     delays_[i].SetClock(this);
 196   }
 197 }
 198
 199 void ResetTraceEventSyntheticDelays() {
 200   TraceEventSyntheticDelayRegistry::GetInstance()->ResetAllDelays();
 201 }
 202
 203 }  // namespace trace_event
 204 }  // namespace base
 205
 206 namespace trace_event_internal {
 207
 208 ScopedSyntheticDelay::ScopedSyntheticDelay(const char* name,
 209                                            base::subtle::AtomicWord* impl_ptr)
 210     : delay_impl_(GetOrCreateDelay(name, impl_ptr)) {
 211   delay_impl_->BeginParallel(&end_time_);
 212 }
 213
 214 ScopedSyntheticDelay::~ScopedSyntheticDelay() {
 215   delay_impl_->EndParallel(end_time_);
 216 }
 217
 218 base::trace_event::TraceEventSyntheticDelay* GetOrCreateDelay(
 219     const char* name,
 220     base::subtle::AtomicWord* impl_ptr) {
 221   base::trace_event::TraceEventSyntheticDelay* delay_impl =
 222       reinterpret_cast<base::trace_event::TraceEventSyntheticDelay*>(
 223           base::subtle::Acquire_Load(impl_ptr));
 224   if (!delay_impl) {
 225     delay_impl =
 226         base::trace_event::TraceEventSyntheticDelayRegistry::GetInstance()
 227             ->GetOrCreateDelay(name);
 228     base::subtle::Release_Store(
 229         impl_ptr, reinterpret_cast<base::subtle::AtomicWord>(delay_impl));
 230   }
 231   return delay_impl;
 232 }
 233
 234 }  // namespace trace_event_internal