Fixit: Fork base::TimeTicks --> TimeTicks + ThreadTicks + TraceTicks

base/threading/thread_perftest.cc

 // Copyright 2014 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/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/scoped_vector.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 30 matching lines @@
         switches::kProfilerTimingDisabledValue);
   }
 
   // To be implemented by each test. Subclass must uses threads_ such that
   // their cpu-time can be measured. Test must return from PingPong() _and_
   // call FinishMeasurement from any thread to complete the test.
   virtual void Init() {}
   virtual void PingPong(int hops) = 0;
   virtual void Reset() {}
 
-  void TimeOnThread(base::TimeTicks* ticks, base::WaitableEvent* done) {
-    *ticks = base::TimeTicks::ThreadNow();
+  void TimeOnThread(base::ThreadTicks* ticks, base::WaitableEvent* done) {
+    *ticks = base::ThreadTicks::Now();
     done->Signal();
   }
 
-  base::TimeTicks ThreadNow(base::Thread* thread) {
+  base::ThreadTicks ThreadNow(base::Thread* thread) {
     base::WaitableEvent done(false, false);
-    base::TimeTicks ticks;
+    base::ThreadTicks ticks;
     thread->task_runner()->PostTask(
         FROM_HERE, base::Bind(&ThreadPerfTest::TimeOnThread,
                               base::Unretained(this), &ticks, &done));
     done.Wait();
     return ticks;
   }
 
   void RunPingPongTest(const std::string& name, unsigned num_threads) {
     // Create threads and collect starting cpu-time for each thread.
-    std::vector<base::TimeTicks> thread_starts;
+    std::vector<base::ThreadTicks> thread_starts;
     while (threads_.size() < num_threads) {
       threads_.push_back(new base::Thread("PingPonger"));
       threads_.back()->Start();
-      if (base::TimeTicks::IsThreadNowSupported())
+      if (base::ThreadTicks::IsSupported())
         thread_starts.push_back(ThreadNow(threads_.back()));
     }
 
     Init();
 
     base::TimeTicks start = base::TimeTicks::Now();
     PingPong(kNumRuns);
     done_.Wait();
     base::TimeTicks end = base::TimeTicks::Now();
 
     // Gather the cpu-time spent on each thread. This does one extra tasks,
     // but that should be in the noise given enough runs.
     base::TimeDelta thread_time;
     while (threads_.size()) {
-      if (base::TimeTicks::IsThreadNowSupported()) {
+      if (base::ThreadTicks::IsSupported()) {
         thread_time += ThreadNow(threads_.back()) - thread_starts.back();
         thread_starts.pop_back();
       }
       threads_.pop_back();
     }
 
     Reset();
 
     double num_runs = static_cast<double>(kNumRuns);
     double us_per_task_clock = (end - start).InMicroseconds() / num_runs;
     double us_per_task_cpu = thread_time.InMicroseconds() / num_runs;
 
     // Clock time per task.
     perf_test::PrintResult(
         "task", "", name + "_time ", us_per_task_clock, "us/hop", true);
 
     // Total utilization across threads if available (likely higher).
-    if (base::TimeTicks::IsThreadNowSupported()) {
+    if (base::ThreadTicks::IsSupported()) {
       perf_test::PrintResult(
           "task", "", name + "_cpu ", us_per_task_cpu, "us/hop", true);
     }
   }
 
  protected:
   void FinishMeasurement() { done_.Signal(); }
   ScopedVector<base::Thread> threads_;
 
  private:
@@ skipping 183 matching lines @@
 typedef EventPerfTest<PthreadEvent> PthreadEventPerfTest;
 TEST_F(PthreadEventPerfTest, EventPingPong) {
   RunPingPongTest("4_PthreadCondVar_Threads", 4);
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace base