Detect child tasks born during a profiled tasks

base/tracked_objects.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <map>
+#include <set>
 #include <stack>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/gtest_prod_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/profiler/tracked_time.h"
 #include "base/time.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_local_storage.h"
@@ skipping 169 matching lines @@
 // For a specific thread, and a specific birth place, the collection of all
 // death info (with tallies for each death thread, to prevent access conflicts).
 class ThreadData;
 class BASE_EXPORT BirthOnThread {
  public:
   BirthOnThread(const Location& location, const ThreadData& current);
 
   const Location location() const;
   const ThreadData* birth_thread() const;
 
+  // Insert our state (location, and thread name) into the dictionary.
+  // Use the supplied |prefix| in front of "thread_name" and "location"
+  // respectively when defining keys.
+  void ToValue(const std::string& prefix,
+               base::DictionaryValue* dictionary) const;
+
  private:
   // File/lineno of birth.  This defines the essence of the task, as the context
   // of the birth (construction) often tell what the item is for.  This field
   // is const, and hence safe to access from any thread.
   const Location location_;
 
   // The thread that records births into this object.  Only this thread is
   // allowed to update birth_count_ (which changes over time).
   const ThreadData* const birth_thread_;
 
@@ skipping 87 matching lines @@
 //------------------------------------------------------------------------------
 // A temporary collection of data that can be sorted and summarized.  It is
 // gathered (carefully) from many threads.  Instances are held in arrays and
 // processed, filtered, and rendered.
 // The source of this data was collected on many threads, and is asynchronously
 // changing.  The data in this instance is not asynchronously changing.
 
 class BASE_EXPORT Snapshot {
  public:
   // When snapshotting a full life cycle set (birth-to-death), use this:
-  Snapshot(const BirthOnThread& birth_on_thread, const ThreadData& death_thread,
+  Snapshot(const BirthOnThread& birth_on_thread,
+           const ThreadData& death_thread,
            const DeathData& death_data);
 
   // When snapshotting a birth, with no death yet, use this:
   Snapshot(const BirthOnThread& birth_on_thread, int count);
 
   // Accessor, that provides default value when there is no death thread.
   const std::string DeathThreadName() const;
 
   // Construct a DictionaryValue instance containing all our data recursively.
   // The caller assumes ownership of the memory in the returned instance.
@@ skipping 10 matching lines @@
 // on this thread.  This prevents the need for locking as data accumulates.
 // We use ThreadLocalStorage to quickly identfy the current ThreadData context.
 // We also have a linked list of ThreadData instances, and that list is used to
 // harvest data from all existing instances.
 
 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,
-    ACTIVE,
-    DEACTIVATED,
+    UNINITIALIZED,              // PRistine, link-time state before running.
+    DORMANT_DURING_TESTS,       // Only used during testing.
+    DEACTIVATED,                // No longer recording profling.
+    PROFILING_ACTIVE,           // Recording profiles (no parent-child links).
+    PROFILING_CHILDREN_ACTIVE,  // Fully active, recording parent-child links.
   };
 
   typedef std::map<Location, Births*> 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 40 matching lines @@
   // Record the end of execution in region, generally corresponding to a scope
   // being exited.
   static void TallyRunInAScopedRegionIfTracking(
       const Births* birth,
       const TrackedTime& start_of_run,
       const TrackedTime& end_of_run);
 
   const std::string thread_name() const;
 
   // Snapshot (under a lock) copies of the maps in each ThreadData instance. For
-  // each set of maps (BirthMap and DeathMap) call the Append() method of the
-  // |target| DataCollector.  If |reset_max| is true, then the max values in
-  // each DeathData instance should be reset during the scan.
+  // each set of maps (BirthMap, DeathMap, and ParentChildSet) call the Append()
+  // method of the |target| DataCollector.  If |reset_max| is true, then the max
+  // values in each DeathData instance should be reset during the scan.
   static void SendAllMaps(bool reset_max, class DataCollector* target);
 
   // Hack: asynchronously clear all birth counts and death tallies data values
   // in all ThreadData instances.  The numerical (zeroing) part is done without
   // use of a locks or atomics exchanges, and may (for int64 values) produce
   // bogus counts VERY rarely.
   static void ResetAllThreadData();
 
   // 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_ to either become ACTIVE, or DEACTIVATED,
-  // based on argument being true or false respectively.
+  // 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).
   static bool InitializeAndSetTrackingStatus(bool status);
+
+  // Indicate if any sort of profiling is being done (i.e., we are more than
+  // DEACTIVATED).
   static bool tracking_status();
 
+  // For testing only, indicate if the status of parent-child tracking is turned
+  // on.  This is currently a compiled option, atop tracking_status().
+  static bool tracking_parent_child_status();
+
   // Special versions of Now() for getting times at start and end of a tracked
   // run.  They are super fast when tracking is disabled, and have some internal
   // side effects when we are tracking, so that we can deduce the amount of time
   // accumulated outside of execution of tracked runs.
-  static TrackedTime NowForStartOfRun();
+  // The task that will be tracked is passed in as |parent| so that parent-child
+  // relationships can be (optionally) calculated.
+  static TrackedTime NowForStartOfRun(const Births* parent);
   static TrackedTime NowForEndOfRun();
 
   // 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();
 
   // This function can be called at process termination to validate that thread
   // cleanup routines have been called for at least some number of named
   // threads.
   static void EnsureCleanupWasCalled(int major_threads_shutdown_count);
 
  private:
   // 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);
 
   // Worker thread construction creates a name since there is none.
   explicit ThreadData(int thread_number);
 
   // Message loop based construction should provide a name.
   explicit ThreadData(const std::string& suggested_name);
 
   ~ThreadData();
 
   // Push this instance to the head of all_thread_data_list_head_, linking it to
@@ skipping 16 matching lines @@
                    DurationInt queue_duration,
                    DurationInt duration);
 
   // 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 reallocaed while they are copied. If |reset_max| is
   // true, then, just after we copy the DeathMap, we will set the max values to
   // zero in the active DeathMap (not the snapshot).
   void SnapshotMaps(bool reset_max,
                     BirthMap* birth_map,
-                    DeathMap* death_map);
+                    DeathMap* death_map,
+                    ParentChildSet* parent_child_set);
 
   // Using our lock to protect the iteration, Clear all birth and death data.
   void Reset();
 
   // 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
   // can save all the thread data into a cache of reusable ThreadData instances.
@@ skipping 38 matching lines @@
   // value is only accessed while the list_lock_ is held.
   static int incarnation_counter_;
 
   // Protection for access to all_thread_data_list_head_, and to
   // unregistered_thread_data_pool_.  This lock is leaked at shutdown.
   // The lock is very infrequently used, so we can afford to just make a lazy
   // instance and be safe.
   static base::LazyInstance<base::Lock,
       base::LeakyLazyInstanceTraits<base::Lock> > list_lock_;
 
-  // 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
-  // incarations).
-  int incarnation_count_for_pool_;
-
   // We set status_ to SHUTDOWN when we shut down the tracking service.
   static Status status_;
 
   // Link to next instance (null terminated list). Used to globally track all
   // registered instances (corresponds to all registered threads where we keep
   // data).
   ThreadData* next_;
 
   // Pointer to another ThreadData instance for a Worker-Thread that has been
   // retired (its thread was terminated).  This value is non-NULL only for a
@@ skipping 15 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 NowForStartOfRun(), 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 porfiles, 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.
   int32 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).
+  int incarnation_count_for_pool_;
+
   DISALLOW_COPY_AND_ASSIGN(ThreadData);
 };
 
 //------------------------------------------------------------------------------
 // DataCollector is a container class for Snapshot and BirthOnThread count
 // items.
 
 class BASE_EXPORT DataCollector {
  public:
   typedef std::vector<Snapshot> Collection;
 
   // Construct with a list of how many threads should contribute.  This helps us
   // determine (in the async case) when we are done with all contributions.
   DataCollector();
   ~DataCollector();
 
   // Adds all stats from the indicated thread into our arrays.  Accepts copies
   // of the birth_map and death_map, so that the data will not change during the
   // iterations and processing.
   void Append(const ThreadData &thread_data,
-              const ThreadData::BirthMap &birth_map,
-              const ThreadData::DeathMap &death_map);
+              const ThreadData::BirthMap& birth_map,
+              const ThreadData::DeathMap& death_map,
+              const ThreadData::ParentChildSet& parent_child_set);
 
   // After the accumulation phase, the following accessor is used to process the
   // data (i.e., sort it, filter it, etc.).
   Collection* collection();
 
   // Adds entries for all the remaining living objects (objects that have
   // tallied a birth, but have not yet tallied a matching death, and hence must
   // be either running, queued up, or being held in limbo for future posting).
   // This should be called after all known ThreadData instances have been
   // processed using Append().
   void AddListOfLivingObjects();
 
-  // Generates a ListValue representation of the vector of snapshots. The caller
-  // assumes ownership of the memory in the returned instance.
-  base::ListValue* ToValue() const;
+  // Generates a ListValue representation of the vector of snapshots, and
+  // inserts the results into |dictionary|.
+  void ToValue(base::DictionaryValue* dictionary) const;
 
  private:
   typedef std::map<const BirthOnThread*, int> BirthCount;
 
   // The array that we collect data into.
   Collection collection_;
 
   // The total number of births recorded at each location for which we have not
   // seen a death count.  This map changes as we do Append() calls, and is later
   // used by AddListOfLivingObjects() to gather up unaccounted for births.
   BirthCount global_birth_count_;
 
+  // The complete list of parent-child relationships among tasks.
+  ThreadData::ParentChildSet parent_child_set_;
+
   DISALLOW_COPY_AND_ASSIGN(DataCollector);
 };
 
 //------------------------------------------------------------------------------
 // Provide simple way to to start global tracking, and to tear down tracking
 // when done.  The design has evolved to *not* do any teardown (and just leak
 // all allocated data structures).  As a result, we don't have any code in this
 // destructor, and perhaps this whole class should go away.
 
 class BASE_EXPORT AutoTracking {
@@ skipping 10 matching lines @@
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_