Update task tracking to not depend on message_loop_ singleton

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 <string>
@@ skipping 47 matching lines @@
 // freely accessed by any thread at any time (i.e., only the statistic needs to
 // be handled carefully, and it is ONLY read or written by the birth thread).
 //
 // For Tasks, having now either constructed or found the Births instance
 // described above, a pointer to the Births instance is then recorded into the
 // PendingTask structure in MessageLoop.  This fact alone is very useful in
 // debugging, when there is a question of where an instance came from.  In
 // addition, the birth time is also recorded and used to later evaluate the
 // lifetime duration of the whole Task.  As a result of the above embedding, we
 // can find out a Task's location of birth, and thread of birth, without using
-// any locks, as all that data is constant across the life of the process.
+// any locks, as all that data is constant across the life of the process. We
+// currently over-write the birth time with the time at which a Run() of the
+// task begins, so that we can calculate execution time independendent of
+// queueuing time (time spent in delayed task queues, or regular queues).
 //
 // This can also be done for any other object as well by calling
 // TallyABirthIfActive() and TallyADeathIfActive() as appropriate.
 //
 // The amount of memory used in the above data structures depends on how many
 // threads there are, and how many Locations of construction there are.
 // Fortunately, we don't use memory that is the product of those two counts, but
 // rather we only need one Births instance for each thread that constructs an
 // instance at a Location. In many cases, instances are only created on one
 // thread, so the memory utilization is actually fairly restrained.
 //
 // Lastly, when an instance is deleted, the final tallies of statistics are
 // carefully accumulated.  That tallying wrties into slots (members) in a
 // collection of DeathData instances.  For each birth place Location that is
 // destroyed on a thread, there is a DeathData instance to record the additional
-// death count, as well as accumulate the lifetime duration of the instance as
+// death count, as well as accumulate the Run()time duration of the instance as
 // it is destroyed (dies).  By maintaining a single place to aggregate this
 // addition *only* for the given thread, we avoid the need to lock such
 // DeathData instances.
 //
 // With the above lifecycle description complete, the major remaining detail is
 // explaining how each thread maintains a list of DeathData instances, and of
 // Births instances, and is able to avoid additional (redundant/unnecessary)
 // allocations.
 //
 // Each thread maintains a list of data items specific to that thread in a
@@ skipping 111 matching lines @@
 };
 
 //------------------------------------------------------------------------------
 // Basic info summarizing multiple destructions of an object with a single
 // birthplace (fixed Location).  Used both on specific threads, and also used
 // in snapshots when integrating assembled data.
 
 class BASE_EXPORT DeathData {
  public:
   // Default initializer.
-  DeathData() : count_(0), square_duration_(0) {}
+  DeathData() : count_(0) {}
 
   // When deaths have not yet taken place, and we gather data from all the
   // threads, we create DeathData stats that tally the number of births without
   // a corrosponding death.
-  explicit DeathData(int count) : count_(count), square_duration_(0) {}
+  explicit DeathData(int count) : count_(count) {}
 
+  // Update stats for a task destruction (death) that had a Run() time of
+  // |duration|.
   void RecordDeath(const base::TimeDelta& duration);
 
   // Metrics accessors.
   int count() const { return count_; }
   base::TimeDelta life_duration() const { return life_duration_; }
-  int64 square_duration() const { return square_duration_; }
   int AverageMsDuration() const;
   double StandardDeviation() const;
 
   // Accumulate metrics from other into this.
   void AddDeathData(const DeathData& other);
 
   // Simple print of internal state.
   void Write(std::string* output) const;
 
   // Reset all tallies to zero.
   void Clear();
 
  private:
-  int count_;                // Number of destructions.
-  base::TimeDelta life_duration_;    // Sum of all lifetime durations.
-  int64 square_duration_;  // Sum of squares in milliseconds.
+  int count_;                      // Number of destructions.
+  base::TimeDelta life_duration_;  // Sum of all Run()time durations.
 };
 
 //------------------------------------------------------------------------------
 // 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,
            const DeathData& death_data);
 
   // When snapshotting a birth, with no death yet, use this:
   Snapshot(const BirthOnThread& birth_on_thread, int count);
 
 
   const ThreadData* birth_thread() const { return birth_->birth_thread(); }
   const Location location() const { return birth_->location(); }
   const BirthOnThread& birth() const { return *birth_; }
   const ThreadData* death_thread() const {return death_thread_; }
   const DeathData& death_data() const { return death_data_; }
   const std::string DeathThreadName() const;
 
   int count() const { return death_data_.count(); }
   base::TimeDelta life_duration() const { return death_data_.life_duration(); }
-  int64 square_duration() const { return death_data_.square_duration(); }
   int AverageMsDuration() const { return death_data_.AverageMsDuration(); }
 
   void Write(std::string* output) const;
 
   void Add(const Snapshot& other);
 
  private:
   const BirthOnThread* birth_;  // Includes Location and birth_thread.
   const ThreadData* death_thread_;
   DeathData death_data_;
@@ skipping 181 matching lines @@
 
 //------------------------------------------------------------------------------
 // For each thread, we have a ThreadData that stores all tracking info generated
 // on this thread.  This prevents the need for locking as data accumulates.
 
 class BASE_EXPORT ThreadData {
  public:
   typedef std::map<Location, Births*> BirthMap;
   typedef std::map<const Births*, DeathData> DeathMap;
 
-  ThreadData();
+  explicit ThreadData(const char* suggested_name);
   ~ThreadData();
 
   // 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.
   // If shutdown has already started, and we don't yet have an instance, then
   // return null.
-  static ThreadData* current();
+  static ThreadData* FactoryGet(const char* suggested_name);
 
   // For a given (unescaped) about:tracking query, develop resulting HTML, and
   // append to output.
   static void WriteHTML(const std::string& query, std::string* output);
 
   // For a given accumulated array of results, use the comparator to sort and
   // subtotal, writing the results to the output.
   static void WriteHTMLTotalAndSubtotals(
       const DataCollector::Collection& match_array,
       const Comparator& comparator, std::string* output);
 
   // In this thread's data, record a new birth.
   Births* TallyABirth(const Location& location);
 
   // Find a place to record a death on this thread.
-  void TallyADeath(const Births& lifetimes, const base::TimeDelta& duration);
+  void TallyADeath(const Births& the_birth, const base::TimeDelta& duration);
 
   // Helper methods to only tally if the current thread has tracking active.
   //
   // TallyABirthIfActive will returns NULL if the birth cannot be tallied.
   static Births* TallyABirthIfActive(const Location& location);
-  static void TallyADeathIfActive(const Births* lifetimes,
-                                  const base::TimeDelta& duration);
+
+  // Record the end of a timed run of an object.  The |the_birth| is the record
+  // for the instance, the |time_posted| and |start_of_run| are times of posting
+  // into a message loop queue, and of starting to perform the run of the task.
+  // Implied is that the run just (Now()) ended.  The current_message_loop is
+  // optional, and only used in DEBUG mode (when supplied) to verify that the
+  // ThreadData has a thread name that does indeed match the given loop's
+  // associated thread name (in RELEASE mode, its use is compiled away).
+  static void TallyADeathIfActive(const Births* the_birth,
+                                  const base::TimeTicks& time_posted,
+                                  const base::TimeTicks& start_of_run,
+                                  const MessageLoop* current_message_loop);
 
   // (Thread safe) Get start of list of instances.
   static ThreadData* first();
   // Iterate through the null terminated list of instances.
   ThreadData* next() const { return next_; }
 
-  MessageLoop* message_loop() const { return message_loop_; }
-  const std::string ThreadName() const;
+  const std::string thread_name() const { return thread_name_; }
 
   // Using our lock, make a copy of the specified maps.  These calls may arrive
   // from non-local threads, and are used to quickly scan data from all threads
   // in order to build an HTML page for about:tracking.
   void SnapshotBirthMap(BirthMap *output) const;
   void SnapshotDeathMap(DeathMap *output) const;
 
   // 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();
 
   // Using our lock to protect the iteration, Clear all birth and death data.
   void Reset();
 
   // Using the "known list of threads" gathered during births and deaths, the
   // following attempts to run the given function once all all such threads.
   // Note that the function can only be run on threads which have a message
   // loop!
   static void RunOnAllThreads(void (*Func)());
 
   // Set internal status_ to either become ACTIVE, or later, to be SHUTDOWN,
   // based on argument being true or false respectively.
   // IF tracking is not compiled in, this function will return false.
   static bool StartTracking(bool status);
   static bool IsActive();
 
-#ifdef OS_WIN
-  // WARNING: ONLY call this function when all MessageLoops are still intact for
-  // all registered threads.  IF you call it later, you will crash.
-  // Note: You don't need to call it at all, and you can wait till you are
-  // single threaded (again) to do the cleanup via
-  // ShutdownSingleThreadedCleanup().
-  // Start the teardown (shutdown) process in a multi-thread mode by disabling
-  // further additions to thread database on all threads.  First it makes a
-  // local (locked) change to prevent any more threads from registering.  Then
-  // it Posts a Task to all registered threads to be sure they are aware that no
-  // more accumulation can take place.
-  static void ShutdownMultiThreadTracking();
-#endif
+  // 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 base::TimeTicks Now();
 
   // WARNING: ONLY call this function when you are running single threaded
   // (again) and all message loops and threads have terminated.  Until that
   // point some threads may still attempt to write into our data structures.
   // Delete recursively all data structures, starting with the list of
   // ThreadData instances.
   static void ShutdownSingleThreadedCleanup();
 
  private:
   // Current allowable states of the tracking system.  The states always
   // proceed towards SHUTDOWN, and never go backwards.
   enum Status {
     UNINITIALIZED,
     ACTIVE,
     SHUTDOWN,
   };
 
-#if defined(OS_WIN)
-  class ThreadSafeDownCounter;
-  class RunTheStatic;
-#endif
-
   // Each registered thread is called to set status_ to SHUTDOWN.
   // This is done redundantly on every registered thread because it is not
   // protected by a mutex.  Running on all threads guarantees we get the
   // notification into the memory cache of all possible threads.
   static void ShutdownDisablingFurtherTracking();
 
   // We use thread local store to identify which ThreadData to interact with.
   static base::ThreadLocalStorage::Slot tls_index_;
 
   // Link to the most recently created instance (starts a null terminated list).
   static ThreadData* first_;
   // Protection for access to first_.
   static base::Lock list_lock_;
 
   // We set status_ to SHUTDOWN when we shut down the tracking service. This
   // setting is redundantly established by all participating threads so that we
   // are *guaranteed* (without locking) that all threads can "see" the status
   // and avoid additional calls into the  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_;
 
-  // The message loop where tasks needing to access this instance's private data
-  // should be directed.  Since some threads have no message loop, some
-  // instances have data that can't be (safely) modified externally.
-  MessageLoop* message_loop_;
+  // The name of the thread that is being recorded.  If this is a worker thread,
+  // or has no message_loop, then this string is empty.
+  std::string thread_name_;
+
+  // A sequential number indicating when this thread context was created. If
+  // the thread_name_ is empty, then this values will be used to form a unique
+  // name.
+  int thread_number_;
 
   // A map used on each thread to keep track of Births on this thread.
   // This map should only be accessed on the thread it was constructed on.
   // 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_;
 
   // 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 lock_;
 
+  // The next available thread number.  This should only be accessed when the
+  // list_lock_ is held.
+  static int thread_number_counter;
+
   DISALLOW_COPY_AND_ASSIGN(ThreadData);
 };
 
 
 //------------------------------------------------------------------------------
 // Provide simple way to to start global tracking, and to tear down tracking
 // when done.  Note that construction and destruction of this object must be
 // done when running in  threaded mode (before spawning a lot of threads
 // for construction, and after shutting down all the threads for destruction).
 
@@ skipping 30 matching lines @@
   };
   static State state_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_