Cleanup: removing unused descendants information from tracked objects

base/tracked_objects.h

 // 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.
 
 #ifndef BASE_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 
 #include <map>
 #include <set>
 #include <stack>
@@ skipping 136 matching lines @@
 // instances for each combination of birth thread, death thread, and location,
 // along with the count of such lifetimes.  We gather such data into a
 // TaskSnapshot instances, so that such instances can be sorted and
 // aggregated (and remain frozen during our processing).
 //
 // Profiling consists of phases.  The concrete phase in the sequence of phases
 // is identified by its 0-based index.
 //
 // The ProcessDataPhaseSnapshot struct is a serialized representation of the
 // list of ThreadData objects for a process for a concrete profiling phase.  It
-// holds a set of TaskSnapshots and tracks parent/child relationships for the
-// executed tasks.  The statistics in a snapshot are gathered asynhcronously
-// relative to their ongoing updates.
+// holds a set of TaskSnapshots.  The statistics in a snapshot are gathered
+// asynhcronously relative to their ongoing updates.
 // It is possible, though highly unlikely, that stats could be incorrectly
 // recorded by this process (all data is held in 32 bit ints, but we are not
 // atomically collecting all data, so we could have count that does not, for
 // example, match with the number of durations we accumulated).  The advantage
 // to having fast (non-atomic) updates of the data outweighs the minimal risk of
 // a singular corrupt statistic snapshot (only the snapshot could be corrupt,
 // not the underlying and ongoing statistic).  In contrast, pointer data that
 // is accessed during snapshotting is completely invariant, and hence is
 // perfectly acquired (i.e., no potential corruption, and no risk of a bad
 // memory reference).
 //
 // TODO(jar): We can implement a Snapshot system that *tries* to grab the
 // snapshots on the source threads *when* they have MessageLoops available
 // (worker threads don't have message loops generally, and hence gathering from
 // them will continue to be asynchronous).  We had an implementation of this in
 // the past, but the difficulty is dealing with message loops being terminated.
 // We can *try* to spam the available threads via some message loop proxy to
 // achieve this feat, and it *might* be valuable when we are collecting data
 // for upload via UMA (where correctness of data may be more significant than
 // for a single screen of about:profiler).
 //
-// TODO(jar): We should support (optionally) the recording of parent-child
-// relationships for tasks.  This should be done by detecting what tasks are
-// Born during the running of a parent task.  The resulting data can be used by
-// a smarter profiler to aggregate the cost of a series of child tasks into
-// the ancestor task.  It can also be used to illuminate what child or parent is
-// related to each task.
-//
 // TODO(jar): We need to store DataCollections, and provide facilities for
 // taking the difference between two gathered DataCollections.  For now, we're
 // just adding a hack that Reset()s to zero all counts and stats.  This is also
 // done in a slightly thread-unsafe fashion, as the resetting is done
 // asynchronously relative to ongoing updates (but all data is 32 bit in size).
 // For basic profiling, this will work "most of the time," and should be
 // sufficient... but storing away DataCollections is the "right way" to do this.
 // We'll accomplish this via JavaScript storage of snapshots, and then we'll
 // remove the Reset() methods.  We may also need a short-term-max value in
 // DeathData that is reset (as synchronously as possible) during each snapshot.
@@ skipping 225 matching lines @@
 // Map from profiling phase number to the process-wide snapshotted
 // representation of the list of ThreadData objects that died during the given
 // phase.
 typedef std::map<int, ProcessDataPhaseSnapshot> PhasedProcessDataSnapshotMap;
 
 class BASE_EXPORT ThreadData {
  public:
   // Current allowable states of the tracking system.  The states can vary
   // between ACTIVE and DEACTIVATED, but can never go back to UNINITIALIZED.
   enum Status {
-    UNINITIALIZED,              // PRistine, link-time state before running.
-    DORMANT_DURING_TESTS,       // Only used during testing.
-    DEACTIVATED,                // No longer recording profiling.
-    PROFILING_ACTIVE,           // Recording profiles (no parent-child links).
-    PROFILING_CHILDREN_ACTIVE,  // Fully active, recording parent-child links.
-    STATUS_LAST = PROFILING_CHILDREN_ACTIVE
+    UNINITIALIZED,         // Pristine, link-time state before running.
+    DORMANT_DURING_TESTS,  // Only used during testing.
+    DEACTIVATED,           // No longer recording profiling.
+    PROFILING_ACTIVE,      // Recording profiles.
+    STATUS_LAST = PROFILING_ACTIVE
   };
 
   typedef base::hash_map<Location, Births*, Location::Hash> BirthMap;
   typedef std::map<const Births*, DeathData> DeathMap;
-  typedef std::pair<const Births*, const Births*> ParentChildPair;
-  typedef std::set<ParentChildPair> ParentChildSet;
-  typedef std::stack<const Births*> ParentStack;
 
   // Initialize the current thread context with a new instance of ThreadData.
   // This is used by all threads that have names, and should be explicitly
   // set *before* any births on the threads have taken place.  It is generally
   // only used by the message loop, which has a well defined thread name.
   static void InitializeThreadContext(const std::string& suggested_name);
 
   // Using Thread Local Store, find the current instance for collecting data.
   // If an instance does not exist, construct one (and remember it for use on
   // this thread.
@@ skipping 51 matching lines @@
                                                 const TaskStopwatch& stopwatch);
 
   const std::string& thread_name() const { return thread_name_; }
 
   // Initializes all statics if needed (this initialization call should be made
   // while we are single threaded).  Returns false if unable to initialize.
   static bool Initialize();
 
   // Sets internal status_.
   // If |status| is false, then status_ is set to DEACTIVATED.
-  // If |status| is true, then status_ is set to, PROFILING_ACTIVE, or
-  // PROFILING_CHILDREN_ACTIVE.
-  // If tracking is not compiled in, this function will return false.
-  // If parent-child tracking is not compiled in, then an attempt to set the
-  // status to PROFILING_CHILDREN_ACTIVE will only result in a status of
-  // PROFILING_ACTIVE (i.e., it can't be set to a higher level than what is
-  // compiled into the binary, and parent-child tracking at the
-  // PROFILING_CHILDREN_ACTIVE level might not be compiled in).
+  // If |status| is true, then status_ is set to PROFILING_ACTIVE.
+  // If it fails to initialize the TLS slot, this function will return false.
   static bool InitializeAndSetTrackingStatus(Status status);
 
   static Status status();
 
   // Indicate if any sort of profiling is being done (i.e., we are more than
   // DEACTIVATED).
   static bool TrackingStatus();
 
-  // For testing only, indicate if the status of parent-child tracking is turned
-  // on.  This is currently a compiled option, atop TrackingStatus().
-  static bool TrackingParentChildStatus();
-
-  // Marks a start of a tracked run.  It's super fast when tracking is disabled,
-  // and has some internal side effects when we are tracking, so that we can
-  // deduce the amount of time accumulated outside of execution of tracked runs.
-  // The task that will be tracked is passed in as |parent| so that parent-child
-  // relationships can be (optionally) calculated.
-  static void PrepareForStartOfRun(const Births* parent);
-
   // Enables profiler timing.
   static void EnableProfilerTiming();
 
   // Provide a time function that does nothing (runs fast) when we don't have
   // the profiler enabled.  It will generally be optimized away when it is
   // ifdef'ed to be small enough (allowing the profiler to be "compiled out" of
   // the code).
   static TrackedTime Now();
 
   // Use the function |now| to provide current times, instead of calling the
@@ skipping 10 matching lines @@
  private:
   friend class TaskStopwatch;
   // Allow only tests to call ShutdownSingleThreadedCleanup.  We NEVER call it
   // in production code.
   // TODO(jar): Make this a friend in DEBUG only, so that the optimizer has a
   // better change of optimizing (inlining? etc.) private methods (knowing that
   // there will be no need for an external entry point).
   friend class TrackedObjectsTest;
   FRIEND_TEST_ALL_PREFIXES(TrackedObjectsTest, MinimalStartupShutdown);
   FRIEND_TEST_ALL_PREFIXES(TrackedObjectsTest, TinyStartupShutdown);
-  FRIEND_TEST_ALL_PREFIXES(TrackedObjectsTest, ParentChildTest);
 
   typedef std::map<const BirthOnThread*, int> BirthCountMap;
 
   typedef std::vector<std::pair<const Births*, DeathDataPhaseSnapshot>>
       DeathsSnapshot;
 
   // Worker thread construction creates a name since there is none.
   explicit ThreadData(int thread_number);
 
   // Message loop based construction should provide a name.
@@ skipping 30 matching lines @@
   // number of births for the task that have not yet been balanced by a death.
   void SnapshotExecutedTasks(int current_profiling_phase,
                              PhasedProcessDataSnapshotMap* phased_snapshots,
                              BirthCountMap* birth_counts);
 
   // Using our lock, make a copy of the specified maps.  This call may be made
   // on  non-local threads, which necessitate the use of the lock to prevent
   // the map(s) from being reallocated while they are copied.
   void SnapshotMaps(int profiling_phase,
                     BirthMap* birth_map,
-                    DeathsSnapshot* deaths,
-                    ParentChildSet* parent_child_set);
+                    DeathsSnapshot* deaths);
 
   // Called for this thread when the current profiling phase, identified by
   // |profiling_phase|, ends.
   void OnProfilingPhaseCompletedOnThread(int profiling_phase);
 
   // This method is called by the TLS system when a thread terminates.
   // The argument may be NULL if this thread has never tracked a birth or death.
   static void OnThreadTermination(void* thread_data);
 
   // This method should be called when a worker thread terminates, so that we
@@ skipping 81 matching lines @@
   // When a snapshot is needed, this structure can be locked in place for the
   // duration of the snapshotting activity.
   BirthMap birth_map_;
 
   // Similar to birth_map_, this records informations about death of tracked
   // instances (i.e., when a tracked instance was destroyed on this thread).
   // It is locked before changing, and hence other threads may access it by
   // locking before reading it.
   DeathMap death_map_;
 
-  // A set of parents that created children tasks on this thread.  Each pair
-  // corresponds to potentially non-local Births (location and thread), and a
-  // local Births (that took place on this thread).
-  ParentChildSet parent_child_set_;
-
   // Lock to protect *some* access to BirthMap and DeathMap.  The maps are
   // regularly read and written on this thread, but may only be read from other
   // threads.  To support this, we acquire this lock if we are writing from this
   // thread, or reading from another thread.  For reading from this thread we
   // don't need a lock, as there is no potential for a conflict since the
   // writing is only done from this thread.
   mutable base::Lock map_lock_;
 
-  // The stack of parents that are currently being profiled.  This includes only
-  // tasks that have started a timer recently via PrepareForStartOfRun(), but
-  // not yet concluded with a NowForEndOfRun().  Usually this stack is one deep,
-  // but if a scoped region is profiled, or <sigh> a task runs a nested-message
-  // loop, then the stack can grow larger.  Note that we don't try to deduct
-  // time in nested profiles, as our current timer is based on wall-clock time,
-  // and not CPU time (and we're hopeful that nested timing won't be a
-  // significant additional cost).
-  ParentStack parent_stack_;
-
   // A random number that we used to select decide which sample to keep as a
   // representative sample in each DeathData instance.  We can't start off with
   // much randomness (because we can't call RandInt() on all our threads), so
   // we stir in more and more as we go.
   uint32 random_number_;
 
   // Record of what the incarnation_counter_ was when this instance was created.
   // If the incarnation_counter_ has changed, then we avoid pushing into the
   // pool (this is only critical in tests which go through multiple
   // incarnations).
@@ skipping 60 matching lines @@
   // state, then is optionally started/stopped, then destructed.
   enum { CREATED, RUNNING, STOPPED } state_;
 
   // Currently running stopwatch that is directly nested in this one, if such
   // stopwatch exists.  NULL otherwise.
   TaskStopwatch* child_;
 #endif
 };
 
 //------------------------------------------------------------------------------
-// A snapshotted representation of a (parent, child) task pair, for tracking
-// hierarchical profiles.
-
-struct BASE_EXPORT ParentChildPairSnapshot {
- public:
-  ParentChildPairSnapshot();
-  explicit ParentChildPairSnapshot(
-      const ThreadData::ParentChildPair& parent_child);
-  ~ParentChildPairSnapshot();
-
-  BirthOnThreadSnapshot parent;
-  BirthOnThreadSnapshot child;
-};
-
-//------------------------------------------------------------------------------
 // A snapshotted representation of the list of ThreadData objects for a process,
 // for a single profiling phase.
 
 struct BASE_EXPORT ProcessDataPhaseSnapshot {
  public:
   ProcessDataPhaseSnapshot();
   ~ProcessDataPhaseSnapshot();
 
   std::vector<TaskSnapshot> tasks;
-  std::vector<ParentChildPairSnapshot> descendants;
 };
 
 //------------------------------------------------------------------------------
 // A snapshotted representation of the list of ThreadData objects for a process,
 // for all profiling phases, including the current one.
 
 struct BASE_EXPORT ProcessDataSnapshot {
  public:
   ProcessDataSnapshot();
   ~ProcessDataSnapshot();
 
   PhasedProcessDataSnapshotMap phased_snapshots;
   base::ProcessId process_id;
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_