profiler: cleanup unused alternate_timer code

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 <limits.h>
 #include <stdlib.h>
 
 #include "base/atomicops.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/leak_annotations.h"
 #include "base/logging.h"
 #include "base/process/process_handle.h"
-#include "base/profiler/alternate_timer.h"
 #include "base/strings/stringprintf.h"
 #include "base/third_party/valgrind/memcheck.h"
 #include "base/tracking_info.h"
 #include "build/build_config.h"
 
 using base::TimeDelta;
 
 namespace base {
 class TimeDelta;
 }
 
 namespace tracked_objects {
 
 namespace {
 // When ThreadData is first initialized, should we start in an ACTIVE state to
 // record all of the startup-time tasks, or should we start up DEACTIVATED, so
 // that we only record after parsing the command line flag --enable-tracking.
 // Note that the flag may force either state, so this really controls only the
 // period of time up until that flag is parsed.  If there is no flag seen, then
 // this state may prevail for much or all of the process lifetime.
 const ThreadData::Status kInitialStartupState = ThreadData::PROFILING_ACTIVE;
 
 // Control whether an alternate time source (Now() function) is supported by
 // the ThreadData class.  This compile time flag should be set to true if we
 // want other modules (such as a memory allocator, or a thread-specific CPU time
 // clock) to be able to provide a thread-specific Now() function.  Without this
 // compile-time flag, the code will only support the wall-clock time.  This flag
 // can be flipped to efficiently disable this path (if there is a performance
 // problem with its presence).
 static const bool kAllowAlternateTimeSourceHandling = true;

[Ilya Sherman, 2016/01/28 01:36:47]

Can this be removed?

[Primiano Tucci (use gerrit), 2016/01/28 10:46:36]

Yeah this sounds a "just in case" switch to make the code faster that we really
never used (also because it would break the ability of testing)

 
 // Possible states of the profiler timing enabledness.
 enum {
   UNDEFINED_TIMING,
   ENABLED_TIMING,
   DISABLED_TIMING,
 };
 
 // State of the profiler timing enabledness.
 base::subtle::Atomic32 g_profiler_timing_enabled = UNDEFINED_TIMING;
@@ skipping 220 matching lines @@
 
 //------------------------------------------------------------------------------
 // ThreadData maintains the central data for all births and deaths on a single
 // thread.
 
 // TODO(jar): We should pull all these static vars together, into a struct, and
 // optimize layout so that we benefit from locality of reference during accesses
 // to them.
 
 // static
-NowFunction* ThreadData::now_function_ = NULL;
+ThreadData::NowFunction* ThreadData::now_function_ = NULL;
 
 // static
 bool ThreadData::now_function_is_time_ = false;
 
 // A TLS slot which points to the ThreadData instance for the current thread.
 // We do a fake initialization here (zeroing out data), and then the real
 // in-place construction happens when we call tls_index_.Initialize().
 // static
 base::ThreadLocalStorage::StaticSlot ThreadData::tls_index_ = TLS_INITIALIZER;
 
@@ skipping 386 matching lines @@
 }
 
 void ThreadData::OnProfilingPhaseCompletedOnThread(int profiling_phase) {
   base::AutoLock lock(map_lock_);
 
   for (auto& death : death_map_) {
     death.second.OnProfilingPhaseCompleted(profiling_phase);
   }
 }
 
-static void OptionallyInitializeAlternateTimer() {
-  NowFunction* alternate_time_source = GetAlternateTimeSource();
-  if (alternate_time_source)
-    ThreadData::SetAlternateTimeSource(alternate_time_source);
-}
-
 void ThreadData::Initialize() {
   if (base::subtle::Acquire_Load(&status_) >= DEACTIVATED)
     return;  // Someone else did the initialization.
   // Due to racy lazy initialization in tests, we'll need to recheck status_
   // after we acquire the lock.
 
   // Ensure that we don't double initialize tls.  We are called when single
   // threaded in the product, but some tests may be racy and lazy about our
   // initialization.
   base::AutoLock lock(*list_lock_.Pointer());
   if (base::subtle::Acquire_Load(&status_) >= DEACTIVATED)
     return;  // Someone raced in here and beat us.
 
-  // Put an alternate timer in place if the environment calls for it, such as
-  // for tracking TCMalloc allocations.  This insertion is idempotent, so we
-  // don't mind if there is a race, and we'd prefer not to be in a lock while
-  // doing this work.
-  if (kAllowAlternateTimeSourceHandling)
-    OptionallyInitializeAlternateTimer();
-
   // Perform the "real" TLS initialization now, and leave it intact through
   // process termination.
   if (!tls_index_.initialized()) {  // Testing may have initialized this.
     DCHECK_EQ(base::subtle::NoBarrier_Load(&status_), UNINITIALIZED);
     tls_index_.Initialize(&ThreadData::OnThreadTermination);
     DCHECK(tls_index_.initialized());
   } else {
     // TLS was initialzed for us earlier.
     DCHECK_EQ(base::subtle::NoBarrier_Load(&status_), DORMANT_DURING_TESTS);
   }
@@ skipping 29 matching lines @@
 // static
 bool ThreadData::TrackingStatus() {
   return base::subtle::Acquire_Load(&status_) > DEACTIVATED;
 }
 
 // static
 void ThreadData::SetAlternateTimeSource(NowFunction* now_function) {
   DCHECK(now_function);
   if (kAllowAlternateTimeSourceHandling)
     now_function_ = now_function;
 }

[Ilya Sherman, 2016/01/28 01:36:47]

Can this be removed?

[Primiano Tucci (use gerrit), 2016/01/28 10:46:36]

Yes, I need to just keep now_function_ for the tests (renaming accordingly)

 
 // static
 void ThreadData::EnableProfilerTiming() {
   base::subtle::NoBarrier_Store(&g_profiler_timing_enabled, ENABLED_TIMING);
 }
 
 // static
 TrackedTime ThreadData::Now() {
   if (kAllowAlternateTimeSourceHandling && now_function_)
     return TrackedTime::FromMilliseconds((*now_function_)());
@@ skipping 224 matching lines @@
     : process_id(base::GetCurrentProcId()) {
 #else
     : process_id(base::kNullProcessId) {
 #endif
 }
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects