Cleanup: removing unused descendants information from tracked objects

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"
@@ skipping 10 matching lines @@
 
 using base::TimeDelta;
 
 namespace base {
 class TimeDelta;
 }
 
 namespace tracked_objects {
 
 namespace {
-// TODO(jar): Evaluate the perf impact of enabling this.  If the perf impact is
-// negligible, enable by default.
-// Flag to compile out parent-child link recording.
-const bool kTrackParentChildLinks = false;
-
 // 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_CHILDREN_ACTIVE;
+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;
 
@@ skipping 467 matching lines @@
     child =  it->second;
     child->RecordBirth();
   } else {
     child = new Births(location, *this);  // Leak this.
     // 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;
   }
 
-  if (kTrackParentChildLinks && status_ > PROFILING_ACTIVE &&
-      !parent_stack_.empty()) {
-    const Births* parent = parent_stack_.top();
-    ParentChildPair pair(parent, child);
-    if (parent_child_set_.find(pair) == parent_child_set_.end()) {
-      // 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_);
-      parent_child_set_.insert(pair);
-    }
-  }
-
   return child;
 }
 
 void ThreadData::TallyADeath(const Births& births,
                              int32 queue_duration,
                              const TaskStopwatch& stopwatch) {
   int32 run_duration = stopwatch.RunDurationMs();
 
   // Stir in some randomness, plus add constant in case durations are zero.
   const uint32 kSomePrimeNumber = 2147483647;
@@ skipping 13 matching lines @@
 
   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.
     death_data = &death_map_[&births];
   }  // Release lock ASAP.
   death_data->RecordDeath(queue_duration, run_duration, random_number_);
-
-  if (!kTrackParentChildLinks)
-    return;
-  if (!parent_stack_.empty()) {  // We might get turned off.
-    DCHECK_EQ(parent_stack_.top(), &births);
-    parent_stack_.pop();
-  }
 }
 
 // static
 Births* ThreadData::TallyABirthIfActive(const Location& location) {
   if (!TrackingStatus())
     return NULL;
   ThreadData* current_thread_data = Get();
   if (!current_thread_data)
     return NULL;
   return current_thread_data->TallyABirth(location);
@@ skipping 78 matching lines @@
 }
 
 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;
   DeathsSnapshot deaths;
-  ParentChildSet parent_child_set;
-  SnapshotMaps(current_profiling_phase, &birth_map, &deaths, &parent_child_set);
+  SnapshotMaps(current_profiling_phase, &birth_map, &deaths);
 
   for (const auto& birth : birth_map) {
     (*birth_counts)[birth.second] += birth.second->birth_count();
   }
 
   for (const auto& death : deaths) {
     (*birth_counts)[death.first] -= death.first->birth_count();
 
     // For the current death data, walk through all its snapshots, starting from
     // the current one, then from the previous profiling phase etc., and for
@@ skipping 10 matching lines @@
             TaskSnapshot(BirthOnThreadSnapshot(*death.first), death_data,
                          thread_name()));
       }
     }
   }
 }
 
 // This may be called from another thread.
 void ThreadData::SnapshotMaps(int profiling_phase,
                               BirthMap* birth_map,
-                              DeathsSnapshot* deaths,
-                              ParentChildSet* parent_child_set) {
+                              DeathsSnapshot* deaths) {
   base::AutoLock lock(map_lock_);
 
   for (const auto& birth : birth_map_)
     (*birth_map)[birth.first] = birth.second;
 
   for (const auto& death : death_map_) {
     deaths->push_back(std::make_pair(
         death.first,
         DeathDataPhaseSnapshot(profiling_phase, death.second.count(),
                                death.second.run_duration_sum(),
                                death.second.run_duration_max(),
                                death.second.run_duration_sample(),
                                death.second.queue_duration_sum(),
                                death.second.queue_duration_max(),
                                death.second.queue_duration_sample(),
                                death.second.last_phase_snapshot())));
   }
-
-  if (!kTrackParentChildLinks)
-    return;
-
-  for (const auto& parent_child : parent_child_set_)
-    parent_child_set->insert(parent_child);
 }
 
 void ThreadData::OnProfilingPhaseCompletedOnThread(int profiling_phase) {
   base::AutoLock lock(map_lock_);
 
   for (auto& death : death_map_) {
     death.second.OnProfilingPhaseCompleted(profiling_phase);
   }
 }
 
@@ skipping 36 matching lines @@
   }
 
   // Incarnation counter is only significant to testing, as it otherwise will
   // never again change in this process.
   ++incarnation_counter_;
 
   // The lock is not critical for setting status_, but it doesn't hurt.  It also
   // ensures that if we have a racy initialization, that we'll bail as soon as
   // we get the lock earlier in this method.
   status_ = kInitialStartupState;
-  if (!kTrackParentChildLinks &&
-      kInitialStartupState == PROFILING_CHILDREN_ACTIVE)
-    status_ = PROFILING_ACTIVE;
   DCHECK(status_ != UNINITIALIZED);
   return true;
 }
 
 // static
 bool ThreadData::InitializeAndSetTrackingStatus(Status status) {
   DCHECK_GE(status, DEACTIVATED);
-  DCHECK_LE(status, PROFILING_CHILDREN_ACTIVE);
+  DCHECK_LE(status, PROFILING_ACTIVE);
 
   if (!Initialize())  // No-op if already initialized.
     return false;  // Not compiled in.
 
-  if (!kTrackParentChildLinks && status > DEACTIVATED)
+  if (status > DEACTIVATED)
     status = PROFILING_ACTIVE;
   status_ = status;
   return true;
 }
 
 // static
 ThreadData::Status ThreadData::status() {
   return status_;
 }
 
 // static
 bool ThreadData::TrackingStatus() {
   return status_ > DEACTIVATED;
 }
 
 // static
-bool ThreadData::TrackingParentChildStatus() {
-  return status_ >= PROFILING_CHILDREN_ACTIVE;
-}
-
-// static
-void ThreadData::PrepareForStartOfRun(const Births* parent) {
-  if (kTrackParentChildLinks && parent && status_ > PROFILING_ACTIVE) {
-    ThreadData* current_thread_data = Get();
-    if (current_thread_data)
-      current_thread_data->parent_stack_.push(parent);
-  }
-}
-
-// static
 void ThreadData::SetAlternateTimeSource(NowFunction* now_function) {
   DCHECK(now_function);
   if (kAllowAlternateTimeSourceHandling)
     now_function_ = now_function;
 }
 
 // static
 void ThreadData::EnableProfilerTiming() {
   base::subtle::NoBarrier_Store(&g_profiler_timing_enabled, ENABLED_TIMING);
 }
@@ skipping 206 matching lines @@
                            const std::string& death_thread_name)
     : birth(birth),
       death_data(death_data),
       death_thread_name(death_thread_name) {
 }
 
 TaskSnapshot::~TaskSnapshot() {
 }
 
 //------------------------------------------------------------------------------
-// ParentChildPairSnapshot
-
-ParentChildPairSnapshot::ParentChildPairSnapshot() {
-}
-
-ParentChildPairSnapshot::ParentChildPairSnapshot(
-    const ThreadData::ParentChildPair& parent_child)
-    : parent(*parent_child.first),
-      child(*parent_child.second) {
-}
-
-ParentChildPairSnapshot::~ParentChildPairSnapshot() {
-}
-
-//------------------------------------------------------------------------------
 // ProcessDataPhaseSnapshot
 
 ProcessDataPhaseSnapshot::ProcessDataPhaseSnapshot() {
 }
 
 ProcessDataPhaseSnapshot::~ProcessDataPhaseSnapshot() {
 }
 
 //------------------------------------------------------------------------------
 // ProcessDataPhaseSnapshot
 
 ProcessDataSnapshot::ProcessDataSnapshot()
 #if !defined(OS_NACL)
     : process_id(base::GetCurrentProcId()) {
 #else
     : process_id(base::kNullProcessId) {
 #endif
 }
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects