Switch to a simple linked-list for worker thread pool

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 <stack>
@@ skipping 119 matching lines @@
 // purposes, we need to construct Snapshot instances for each combination of
 // birth thread, death thread, and location, along with the count of such
 // lifetimes.  We gather such data into a Snapshot instances, so that such
 // instances can be sorted and aggregated (and remain frozen during our
 // processing).  Snapshot instances use pointers to constant portions of the
 // birth and death datastructures, but have local (frozen) copies of the actual
 // statistics (birth count, durations, etc. etc.).
 //
 // A DataCollector is a container object that holds a set of Snapshots. The
 // statistics in a snapshot are gathered asynhcronously relative to their
-// ongoing updates.  It is possible, though highly unlikely, that stats such
-// as a 64bit counter could be incorrectly recorded by this process.  The
+// 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 constrast,
 // 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).
 //
 // After an array of Snapshots instances are collected into a DataCollector,
 // they need to be prepared for displaying our output.  We currently implement a
-// direct rendering to HTML, but we will soon have a JSON serialization as well.
-
-// For direct HTML display, the data must be sorted, and possibly aggregated
-// (example: how many threads are in a specific consecutive set of Snapshots?
-// What was the total birth count for that set? etc.).  Aggregation instances
-// collect running sums of any set of snapshot instances, and are used to print
-// sub-totals in an about:profiler page.
+// serialization into a Value hierarchy, which is automatically translated to
+// JSON when supplied to rendering Java Scirpt.
 //
-// TODO(jar): I need to store DataCollections, and provide facilities for taking
-// the difference between two gathered DataCollections.  For now, I'm just
-// adding a hack that Reset()s to zero all counts and stats.  This is also
+// 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 colecting data for
+// upload via UMA (where correctness of data may be more significant than for a
+// single screen of about:profiler).
+//
+// TODO(jar): We need to save a single sample in each DeathData instance of the
+// times recorded.  This sample should be selected in a uniformly random way.
+//
+// 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 slighly 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.
+// 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.
+// This will facilitate displaying a max value for each snapshot period.
 
 class MessageLoop;
 
 namespace tracked_objects {
 
 //------------------------------------------------------------------------------
 // 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 {
@@ skipping 69 matching lines @@
   DurationInt AverageMsRunDuration() const;
   DurationInt run_duration_max() const { return run_time_.max(); }
   DurationInt queue_duration() const { return queue_time_.duration(); }
   DurationInt AverageMsQueueDuration() const;
   DurationInt queue_duration_max() const { return queue_time_.max(); }
 
   // Accumulate metrics from other into this.  This method is never used on
   // realtime statistics, and only used in snapshots and aggregatinos.
   void AddDeathData(const DeathData& other);
 
-  // Simple print of internal state for use in line of HTML.
-  void WriteHTML(std::string* output) const;
-
   // Construct a DictionaryValue instance containing all our stats. The caller
   // assumes ownership of the returned instance.
   base::DictionaryValue* ToValue() const;
 
   // Reset all tallies to zero. This is used as a hack on realtime data.
   void Clear();
 
  private:
   // DeathData::Data is a helper class, useful when different metrics need to be
   // aggregated, such as queueing times, or run times.
   class Data {
    public:
     Data() : duration_(0), max_(0) {}
     ~Data() {}
 
     DurationInt duration() const { return duration_; }
     DurationInt max() const { return max_; }
 
-    // Emits HTML formated description of members, assuming |count| instances
-    // when calculating averages.
-    void WriteHTML(int count, std::string* output) const;
-
     // Agggegate data into our state.
     void AddData(const Data& other);
     void AddDuration(DurationInt duration);
 
     // Central helper function for calculating averages (correctly, in only one
     // place).
     DurationInt AverageMsDuration(int count) const;
 
     // Resets all members to zero.
     void Clear();
@@ skipping 187 matching lines @@
   // The following functions should all be private, and are only public because
   // the collection is done externally.  We need to relocate that code from the
   // collection class into this class, and then all these methods can be made
   // private.
   // (Thread safe) Get start of list of all ThreadData instances.
   static ThreadData* first();
   // Iterate through the null terminated list of ThreadData instances.
   ThreadData* next() const { return next_; }
   // 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:profiler.
+  // in order to build JSON for about:profiler.
   void SnapshotBirthMap(BirthMap *output) const;
   void SnapshotDeathMap(DeathMap *output) const;
   // -------- end of should be private methods.
 
   // 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();
 
@@ skipping 18 matching lines @@
   // 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();
 
  private:
   // Allow only tests to call ShutdownSingleThreadedCleanup.  We NEVER call it
   // in production code.
   friend class TrackedObjectsTest;
 
-  // Implment a stack that avoids allocations during a push() by having enough
-  // space ahead of time.
-  class ThreadDataPool {
-   public:
-    ThreadDataPool();
-    ~ThreadDataPool();
-
-    // Make sure the stack is large enough to support the indicated number of
-    // elements.
-    void reserve(size_t largest_worker_pool_number);
-
-    bool empty() const;
-    const ThreadData* top() const;
-    void push(const ThreadData* thread_data);
-    void pop();
-
-   private:
-    std::vector<const ThreadData*> stack_;
-    size_t empty_slot_;
-    DISALLOW_COPY_AND_ASSIGN(ThreadDataPool);
-  };
-
   // Worker thread construction creates a name since there is none.
-  explicit ThreadData(size_t thread_number);
+  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
   // the previous head.  This is performed after each construction, and leaves
   // the instance permanently on that list.
   void PushToHeadOfList();
 
   // 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& birth,
                    DurationInt queue_duration,
                    DurationInt duration);
 
   // 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.
-  void OnThreadTerminationCleanup() const;
+  void OnThreadTerminationCleanup();
 
   // Cleans up data structures, and returns statics to near pristine (mostly
   // uninitialized) state.  If there is any chance that other threads are still
   // using the data structures, then the |leak| argument should be passed in as
   // true, and the data structures (birth maps, death maps, ThreadData
   // insntances, etc.) will be leaked and not deleted.  If you have joined all
   // threads since the time that InitializeAndSetTrackingStatus() was called,
   // then you can pass in a |leak| value of false, and this function will
   // delete recursively all data structures, starting with the list of
   // ThreadData instances.
   static void ShutdownSingleThreadedCleanup(bool leak);
 
   // We use thread local store to identify which ThreadData to interact with.
   static base::ThreadLocalStorage::Slot tls_index_;
 
+  // List of ThreadData instances for use with worker threads. When a worker
+  // thread is done (terminated), we push it onto this llist.  When a new worker
+  // thread is created, we first try to re-use a ThreadData instance from the
+  // list, and if none are available, construct a new one.
+  // This is only accessed while list_lock_ is held.
+  static ThreadData* first_retired_worker_;
+
   // Link to the most recently created instance (starts a null terminated list).
   // The list is traversed by about:profiler when it needs to snapshot data.
   // This is only accessed while list_lock_ is held.
   static ThreadData* all_thread_data_list_head_;
-  // Set of ThreadData instances for use with worker threads. When a worker
-  // thread is done (terminating), we push it into this pool.  When a new worker
-  // thread is created, we first try to re-use a ThreadData instance from the
-  // pool, and if none are available, construct a new one.
-  // This is only accessed while list_lock_ is held.
-  static ThreadDataPool* unregistered_thread_data_pool_;
   // The next available thread number.  This should only be accessed when the
   // list_lock_ is held.
   static int thread_number_counter_;
   // Incarnation sequence number, indicating how many times (during unittests)
   // we've either transitioned out of UNINITIALIZED, or into that state.  This
   // 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
+  // retired ThreadData associated with a Worker-Thread.
+  ThreadData* next_retired_worker_;
+
   // The name of the thread that is being recorded.  If this thread has no
   // message_loop, then this is a worker thread, with a sequence number postfix.
   std::string thread_name_;
 
   // Indicate if this is a worker thread, and the ThreadData contexts should be
   // stored in the unregistered_thread_data_pool_ when not in use.
   // Value is zero when it is not a worker thread.  Value is a positive integer
   // corresponding to the created thread name if it is a worker thread.
-  size_t worker_thread_number_;
+  int worker_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
@@ skipping 31 matching lines @@
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(AutoTracking);
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_