chrome://profiler infrastructure uses base time types.

base/tracked_objects.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/tracked_objects.h"
 
 #include <ctype.h>
 #include <limits.h>
 #include <stdlib.h>
 
@@ skipping 150 matching lines @@
 // TODO(jar): I need to see if this macro to optimize branching is worth using.
 //
 // This macro has no branching, so it is surely fast, and is equivalent to:
 //             if (assign_it)
 //               target = source;
 // We use a macro rather than a template to force this to inline.
 // Related code for calculating max is discussed on the web.
 #define CONDITIONAL_ASSIGN(assign_it, target, source) \
   ((target) ^= ((target) ^ (source)) & -static_cast<int32_t>(assign_it))
 
-void DeathData::RecordDurations(const int32_t queue_duration,
-                                const int32_t run_duration,
+void DeathData::RecordDurations(const base::TimeDelta queue_duration,
+                                const base::TimeDelta run_duration,
                                 const uint32_t random_number) {
   // We'll just clamp at INT_MAX, but we should note this in the UI as such.
   if (count_ < INT_MAX)
     base::subtle::NoBarrier_Store(&count_, count_ + 1);
 
   int sample_probability_count =
       base::subtle::NoBarrier_Load(&sample_probability_count_);
   if (sample_probability_count < INT_MAX)
     ++sample_probability_count;
   base::subtle::NoBarrier_Store(&sample_probability_count_,
                                 sample_probability_count);
 
-  base::subtle::NoBarrier_Store(&queue_duration_sum_,
-                                queue_duration_sum_ + queue_duration);
-  base::subtle::NoBarrier_Store(&run_duration_sum_,
-                                run_duration_sum_ + run_duration);
+  base::subtle::NoBarrier_Store(
+      &queue_duration_sum_,
+      queue_duration_sum_ + queue_duration.InMilliseconds());
+  base::subtle::NoBarrier_Store(
+      &run_duration_sum_, run_duration_sum_ + run_duration.InMilliseconds());
 
-  if (queue_duration_max() < queue_duration)
-    base::subtle::NoBarrier_Store(&queue_duration_max_, queue_duration);
-  if (run_duration_max() < run_duration)
-    base::subtle::NoBarrier_Store(&run_duration_max_, run_duration);
+  if (queue_duration_max() < queue_duration.InMilliseconds())
+    base::subtle::NoBarrier_Store(&queue_duration_max_,
+                                  queue_duration.InMilliseconds());
+  if (run_duration_max() < run_duration.InMilliseconds())
+    base::subtle::NoBarrier_Store(&run_duration_max_,
+                                  run_duration.InMilliseconds());
 
   // Take a uniformly distributed sample over all durations ever supplied during
   // the current profiling phase.
   // The probability that we (instead) use this new sample is
   // 1/sample_probability_count_. This results in a completely uniform selection
   // of the sample (at least when we don't clamp sample_probability_count_...
   // but that should be inconsequentially likely).  We ignore the fact that we
   // correlated our selection of a sample to the run and queue times (i.e., we
   // used them to generate random_number).
   CHECK_GT(sample_probability_count, 0);
   if (0 == (random_number % sample_probability_count)) {
-    base::subtle::NoBarrier_Store(&queue_duration_sample_, queue_duration);
-    base::subtle::NoBarrier_Store(&run_duration_sample_, run_duration);
+    base::subtle::NoBarrier_Store(&queue_duration_sample_,
+                                  queue_duration.InMilliseconds());
+    base::subtle::NoBarrier_Store(&run_duration_sample_,
+                                  run_duration.InMilliseconds());
   }
 }
 
 void DeathData::RecordAllocations(const uint32_t alloc_ops,
                                   const uint32_t free_ops,
                                   const uint32_t allocated_bytes,
                                   const uint32_t freed_bytes,
                                   const uint32_t alloc_overhead_bytes,
                                   const uint32_t max_allocated_bytes) {
 #if !defined(ARCH_CPU_64_BITS)
@@ skipping 309 matching lines @@
 
 ThreadData::~ThreadData() {
 }
 
 void ThreadData::PushToHeadOfList() {
   // Toss in a hint of randomness (atop the uniniitalized value).
   (void)VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE(&random_number_,
                                                  sizeof(random_number_));
   MSAN_UNPOISON(&random_number_, sizeof(random_number_));
   random_number_ += static_cast<uint32_t>(this - static_cast<ThreadData*>(0));
-  random_number_ ^= (Now() - TrackedTime()).InMilliseconds();
+  random_number_ ^=
+      static_cast<uint32_t>((Now() - base::TimeTicks()).InMilliseconds());
 
   DCHECK(!next_);
   base::AutoLock lock(*list_lock_.Pointer());
   incarnation_count_for_pool_ = incarnation_counter_;
   next_ = all_thread_data_list_head_;
   all_thread_data_list_head_ = this;
 }
 
 // static
 ThreadData* ThreadData::first() {
@@ skipping 124 matching lines @@
     // Lock since the map may get relocated now, and other threads sometimes
     // snapshot it (but they lock before copying it).
     base::AutoLock lock(map_lock_);
     birth_map_[location] = child;
   }
 
   return child;
 }
 
 void ThreadData::TallyADeath(const Births& births,
-                             int32_t queue_duration,
+                             const base::TimeDelta queue_duration,
                              const TaskStopwatch& stopwatch) {
-  int32_t run_duration = stopwatch.RunDurationMs();
+  base::TimeDelta run_duration = stopwatch.RunDuration();
 
   // Stir in some randomness, plus add constant in case durations are zero.
   const uint32_t kSomePrimeNumber = 2147483647;
-  random_number_ += queue_duration + run_duration + kSomePrimeNumber;
+  random_number_ += queue_duration.InMilliseconds() +
+                    run_duration.InMilliseconds() + kSomePrimeNumber;
   // An address is going to have some randomness to it as well ;-).
   random_number_ ^=
       static_cast<uint32_t>(&births - reinterpret_cast<Births*>(0));
 
   DeathMap::iterator it = death_map_.find(&births);
   DeathData* death_data;
   if (it != death_map_.end()) {
     death_data = &it->second;
   } else {
     base::AutoLock lock(map_lock_);  // Lock as the map may get relocated now.
@@ skipping 38 matching lines @@
     return;
   ThreadData* current_thread_data = stopwatch.GetThreadData();
   if (!current_thread_data)
     return;
 
   // Watch out for a race where status_ is changing, and hence one or both
   // of start_of_run or end_of_run is zero.  In that case, we didn't bother to
   // get a time value since we "weren't tracking" and we were trying to be
   // efficient by not calling for a genuine time value.  For simplicity, we'll
   // use a default zero duration when we can't calculate a true value.
-  TrackedTime start_of_run = stopwatch.StartTime();
-  int32_t queue_duration = 0;
+  base::TimeTicks start_of_run = stopwatch.StartTime();
+  base::TimeDelta queue_duration;
   if (!start_of_run.is_null()) {
-    queue_duration = (start_of_run - completed_task.EffectiveTimePosted())
-        .InMilliseconds();
+    queue_duration = start_of_run - completed_task.EffectiveTimePosted();
   }
   current_thread_data->TallyADeath(*births, queue_duration, stopwatch);
 }
 
 // static
 void ThreadData::TallyRunOnWorkerThreadIfTracking(
     const Births* births,
-    const TrackedTime& time_posted,
+    const base::TimeTicks& time_posted,
     const TaskStopwatch& stopwatch) {
   // Even if we have been DEACTIVATED, we will process any pending births so
   // that our data structures (which counted the outstanding births) remain
   // consistent.
   if (!births)
     return;
 
   // TODO(jar): Support the option to coalesce all worker-thread activity under
   // one ThreadData instance that uses locks to protect *all* access.  This will
   // reduce memory (making it provably bounded), but run incrementally slower
   // (since we'll use locks on TallyABirth and TallyADeath).  The good news is
   // that the locks on TallyADeath will be *after* the worker thread has run,
   // and hence nothing will be waiting for the completion (...  besides some
   // other thread that might like to run).  Also, the worker threads tasks are
   // generally longer, and hence the cost of the lock may perchance be amortized
   // over the long task's lifetime.
   ThreadData* current_thread_data = stopwatch.GetThreadData();
   if (!current_thread_data)
     return;
 
-  TrackedTime start_of_run = stopwatch.StartTime();
-  int32_t queue_duration = 0;
+  base::TimeTicks start_of_run = stopwatch.StartTime();
+  base::TimeDelta queue_duration;
   if (!start_of_run.is_null()) {
-    queue_duration = (start_of_run - time_posted).InMilliseconds();
+    queue_duration = start_of_run - time_posted;
   }
   current_thread_data->TallyADeath(*births, queue_duration, stopwatch);
 }
 
 // static
 void ThreadData::TallyRunInAScopedRegionIfTracking(
     const Births* births,
     const TaskStopwatch& stopwatch) {
   // Even if we have been DEACTIVATED, we will process any pending births so
   // that our data structures (which counted the outstanding births) remain
   // consistent.
   if (!births)
     return;
 
   ThreadData* current_thread_data = stopwatch.GetThreadData();
   if (!current_thread_data)
     return;
 
-  int32_t queue_duration = 0;
+  base::TimeDelta queue_duration;
   current_thread_data->TallyADeath(*births, queue_duration, stopwatch);
 }
 
 void ThreadData::SnapshotExecutedTasks(
     int current_profiling_phase,
     PhasedProcessDataSnapshotMap* phased_snapshots,
     BirthCountMap* birth_counts) {
   // Get copy of data, so that the data will not change during the iterations
   // and processing.
   BirthMap birth_map;
@@ skipping 108 matching lines @@
 bool ThreadData::TrackingStatus() {
   return base::subtle::Acquire_Load(&status_) > DEACTIVATED;
 }
 
 // static
 void ThreadData::EnableProfilerTiming() {
   base::subtle::NoBarrier_Store(&g_profiler_timing_enabled, ENABLED_TIMING);
 }
 
 // static
-TrackedTime ThreadData::Now() {
+base::TimeTicks ThreadData::Now() {
   if (now_function_for_testing_)
-    return TrackedTime::FromMilliseconds((*now_function_for_testing_)());
+    return base::TimeTicks() +
+           base::TimeDelta::FromMilliseconds((*now_function_for_testing_)());
   if (IsProfilerTimingEnabled() && TrackingStatus())
-    return TrackedTime::Now();
-  return TrackedTime();  // Super fast when disabled, or not compiled.
+    return base::TimeTicks::Now();
+  return base::TimeTicks();  // Super fast when disabled, or not compiled.
 }
 
 // static
 void ThreadData::EnsureCleanupWasCalled(int major_threads_shutdown_count) {
   base::AutoLock lock(*list_lock_.Pointer());
 
   // TODO(jar): until this is working on XP, don't run the real test.
 #if 0
   // Verify that we've at least shutdown/cleanup the major namesd threads.  The
   // caller should tell us how many thread shutdowns should have taken place by
@@ skipping 83 matching lines @@
       pcursor = &cursor->next_retired_thread_data_;
       cursor = cursor->next_retired_thread_data_;
     }
   }
 
   return new ThreadData(sanitized_thread_name);
 }
 
 //------------------------------------------------------------------------------
 TaskStopwatch::TaskStopwatch()
-    : wallclock_duration_ms_(0),
+    : wallclock_duration_(),
       current_thread_data_(NULL),
-      excluded_duration_ms_(0),
+      excluded_duration_(),
       parent_(NULL) {
 #if DCHECK_IS_ON()
   state_ = CREATED;
   child_ = NULL;
 #endif
 #if BUILDFLAG(USE_ALLOCATOR_SHIM)
   heap_tracking_enabled_ =
       base::debug::ThreadHeapUsageTracker::IsHeapTrackingEnabled();
 #endif
 }
@@ skipping 26 matching lines @@
   if (parent_) {
     DCHECK(parent_->state_ == RUNNING);
     DCHECK(parent_->child_ == NULL);
     parent_->child_ = this;
   }
 #endif
   current_thread_data_->current_stopwatch_ = this;
 }
 
 void TaskStopwatch::Stop() {
-  const TrackedTime end_time = ThreadData::Now();
+  const base::TimeTicks end_time = ThreadData::Now();
 #if DCHECK_IS_ON()
   DCHECK(state_ == RUNNING);
   state_ = STOPPED;
   DCHECK(child_ == NULL);
 #endif
 #if BUILDFLAG(USE_ALLOCATOR_SHIM)
   if (heap_tracking_enabled_)
     heap_usage_.Stop(true);
 #endif
 
   if (!start_time_.is_null() && !end_time.is_null()) {
-    wallclock_duration_ms_ = (end_time - start_time_).InMilliseconds();
+    wallclock_duration_ = end_time - start_time_;
   }
 
   if (!current_thread_data_)
     return;
 
   DCHECK(current_thread_data_->current_stopwatch_ == this);
   current_thread_data_->current_stopwatch_ = parent_;
   if (!parent_)
     return;
 
 #if DCHECK_IS_ON()
   DCHECK(parent_->state_ == RUNNING);
   DCHECK(parent_->child_ == this);
   parent_->child_ = NULL;
 #endif
-  parent_->excluded_duration_ms_ += wallclock_duration_ms_;
+  parent_->excluded_duration_ += wallclock_duration_;
   parent_ = NULL;
 }
 
-TrackedTime TaskStopwatch::StartTime() const {
+base::TimeTicks TaskStopwatch::StartTime() const {
 #if DCHECK_IS_ON()
   DCHECK(state_ != CREATED);
 #endif
 
   return start_time_;
 }
 
-int32_t TaskStopwatch::RunDurationMs() const {
+base::TimeDelta TaskStopwatch::RunDuration() const {
 #if DCHECK_IS_ON()
   DCHECK(state_ == STOPPED);
 #endif
 
-  return wallclock_duration_ms_ - excluded_duration_ms_;
+  return wallclock_duration_ - excluded_duration_;
 }
 
 ThreadData* TaskStopwatch::GetThreadData() const {
 #if DCHECK_IS_ON()
   DCHECK(state_ != CREATED);
 #endif
 
   return current_thread_data_;
 }
 
@@ skipping 45 matching lines @@
 #endif
 }
 
 ProcessDataSnapshot::ProcessDataSnapshot(const ProcessDataSnapshot& other) =
     default;
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects