1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef BASE_TRACKED_OBJECTS_H_
6 #define BASE_TRACKED_OBJECTS_H_
15 #include "base/base_export.h"
16 #include "base/gtest_prod_util.h"
17 #include "base/lazy_instance.h"
18 #include "base/location.h"
19 #include "base/profiler/alternate_timer.h"
20 #include "base/profiler/tracked_time.h"
21 #include "base/time.h"
22 #include "base/synchronization/lock.h"
23 #include "base/threading/thread_local_storage.h"
24 #include "base/tracking_info.h"
26 // TrackedObjects provides a database of stats about objects (generally Tasks)
27 // that are tracked. Tracking means their birth, death, duration, birth thread,
28 // death thread, and birth place are recorded. This data is carefully spread
29 // across a series of objects so that the counts and times can be rapidly
30 // updated without (usually) having to lock the data, and hence there is usually
31 // very little contention caused by the tracking. The data can be viewed via
32 // the about:profiler URL, with a variety of sorting and filtering choices.
34 // These classes serve as the basis of a profiler of sorts for the Tasks system.
35 // As a result, design decisions were made to maximize speed, by minimizing
36 // recurring allocation/deallocation, lock contention and data copying. In the
37 // "stable" state, which is reached relatively quickly, there is no separate
38 // marginal allocation cost associated with construction or destruction of
39 // tracked objects, no locks are generally employed, and probably the largest
40 // computational cost is associated with obtaining start and stop times for
41 // instances as they are created and destroyed.
43 // The following describes the lifecycle of tracking an instance.
45 // First off, when the instance is created, the FROM_HERE macro is expanded
46 // to specify the birth place (file, line, function) where the instance was
47 // created. That data is used to create a transient Location instance
48 // encapsulating the above triple of information. The strings (like __FILE__)
49 // are passed around by reference, with the assumption that they are static, and
50 // will never go away. This ensures that the strings can be dealt with as atoms
51 // with great efficiency (i.e., copying of strings is never needed, and
52 // comparisons for equality can be based on pointer comparisons).
54 // Next, a Births instance is created for use ONLY on the thread where this
55 // instance was created. That Births instance records (in a base class
56 // BirthOnThread) references to the static data provided in a Location instance,
57 // as well as a pointer specifying the thread on which the birth takes place.
58 // Hence there is at most one Births instance for each Location on each thread.
59 // The derived Births class contains slots for recording statistics about all
60 // instances born at the same location. Statistics currently include only the
61 // count of instances constructed.
63 // Since the base class BirthOnThread contains only constant data, it can be
64 // freely accessed by any thread at any time (i.e., only the statistic needs to
65 // be handled carefully, and stats are updated exclusively on the birth thread).
67 // For Tasks, having now either constructed or found the Births instance
68 // described above, a pointer to the Births instance is then recorded into the
69 // PendingTask structure in MessageLoop. This fact alone is very useful in
70 // debugging, when there is a question of where an instance came from. In
71 // addition, the birth time is also recorded and used to later evaluate the
72 // lifetime duration of the whole Task. As a result of the above embedding, we
73 // can find out a Task's location of birth, and thread of birth, without using
74 // any locks, as all that data is constant across the life of the process.
76 // The above work *could* also be done for any other object as well by calling
77 // TallyABirthIfActive() and TallyRunOnNamedThreadIfTracking() as appropriate.
79 // The amount of memory used in the above data structures depends on how many
80 // threads there are, and how many Locations of construction there are.
81 // Fortunately, we don't use memory that is the product of those two counts, but
82 // rather we only need one Births instance for each thread that constructs an
83 // instance at a Location. In many cases, instances are only created on one
84 // thread, so the memory utilization is actually fairly restrained.
86 // Lastly, when an instance is deleted, the final tallies of statistics are
87 // carefully accumulated. That tallying writes into slots (members) in a
88 // collection of DeathData instances. For each birth place Location that is
89 // destroyed on a thread, there is a DeathData instance to record the additional
90 // death count, as well as accumulate the run-time and queue-time durations for
91 // the instance as it is destroyed (dies). By maintaining a single place to
92 // aggregate this running sum *only* for the given thread, we avoid the need to
93 // lock such DeathData instances. (i.e., these accumulated stats in a DeathData
94 // instance are exclusively updated by the singular owning thread).
96 // With the above lifecycle description complete, the major remaining detail is
97 // explaining how each thread maintains a list of DeathData instances, and of
98 // Births instances, and is able to avoid additional (redundant/unnecessary)
101 // Each thread maintains a list of data items specific to that thread in a
102 // ThreadData instance (for that specific thread only). The two critical items
103 // are lists of DeathData and Births instances. These lists are maintained in
104 // STL maps, which are indexed by Location. As noted earlier, we can compare
105 // locations very efficiently as we consider the underlying data (file,
106 // function, line) to be atoms, and hence pointer comparison is used rather than
107 // (slow) string comparisons.
109 // To provide a mechanism for iterating over all "known threads," which means
110 // threads that have recorded a birth or a death, we create a singly linked list
111 // of ThreadData instances. Each such instance maintains a pointer to the next
112 // one. A static member of ThreadData provides a pointer to the first item on
113 // this global list, and access via that all_thread_data_list_head_ item
114 // requires the use of the list_lock_.
115 // When new ThreadData instances is added to the global list, it is pre-pended,
116 // which ensures that any prior acquisition of the list is valid (i.e., the
117 // holder can iterate over it without fear of it changing, or the necessity of
118 // using an additional lock. Iterations are actually pretty rare (used
119 // primarilly for cleanup, or snapshotting data for display), so this lock has
120 // very little global performance impact.
122 // The above description tries to define the high performance (run time)
123 // portions of these classes. After gathering statistics, calls instigated
124 // by visiting about:profiler will assemble and aggregate data for display. The
125 // following data structures are used for producing such displays. They are
126 // not performance critical, and their only major constraint is that they should
127 // be able to run concurrently with ongoing augmentation of the birth and death
130 // This header also exports collection of classes that provide "snapshotted"
131 // representations of the core tracked_objects:: classes. These snapshotted
132 // representations are designed for safe transmission of the tracked_objects::
133 // data across process boundaries. Each consists of:
134 // (1) a default constructor, to support the IPC serialization macros,
135 // (2) a constructor that extracts data from the type being snapshotted, and
136 // (3) the snapshotted data.
138 // For a given birth location, information about births is spread across data
139 // structures that are asynchronously changing on various threads. For
140 // serialization and display purposes, we need to construct TaskSnapshot
141 // instances for each combination of birth thread, death thread, and location,
142 // along with the count of such lifetimes. We gather such data into a
143 // TaskSnapshot instances, so that such instances can be sorted and
144 // aggregated (and remain frozen during our processing).
146 // The ProcessDataSnapshot struct is a serialized representation of the list
147 // of ThreadData objects for a process. It holds a set of TaskSnapshots
148 // and tracks parent/child relationships for the executed tasks. The statistics
149 // in a snapshot are gathered asynhcronously relative to their ongoing updates.
150 // It is possible, though highly unlikely, that stats could be incorrectly
151 // recorded by this process (all data is held in 32 bit ints, but we are not
152 // atomically collecting all data, so we could have count that does not, for
153 // example, match with the number of durations we accumulated). The advantage
154 // to having fast (non-atomic) updates of the data outweighs the minimal risk of
155 // a singular corrupt statistic snapshot (only the snapshot could be corrupt,
156 // not the underlying and ongoing statistic). In constrast, pointer data that
157 // is accessed during snapshotting is completely invariant, and hence is
158 // perfectly acquired (i.e., no potential corruption, and no risk of a bad
159 // memory reference).
161 // TODO(jar): We can implement a Snapshot system that *tries* to grab the
162 // snapshots on the source threads *when* they have MessageLoops available
163 // (worker threads don't have message loops generally, and hence gathering from
164 // them will continue to be asynchronous). We had an implementation of this in
165 // the past, but the difficulty is dealing with message loops being terminated.
166 // We can *try* to spam the available threads via some message loop proxy to
167 // achieve this feat, and it *might* be valuable when we are colecting data for
168 // upload via UMA (where correctness of data may be more significant than for a
169 // single screen of about:profiler).
171 // TODO(jar): We should support (optionally) the recording of parent-child
172 // relationships for tasks. This should be done by detecting what tasks are
173 // Born during the running of a parent task. The resulting data can be used by
174 // a smarter profiler to aggregate the cost of a series of child tasks into
175 // the ancestor task. It can also be used to illuminate what child or parent is
176 // related to each task.
178 // TODO(jar): We need to store DataCollections, and provide facilities for
179 // taking the difference between two gathered DataCollections. For now, we're
180 // just adding a hack that Reset()s to zero all counts and stats. This is also
181 // done in a slighly thread-unsafe fashion, as the resetting is done
182 // asynchronously relative to ongoing updates (but all data is 32 bit in size).
183 // For basic profiling, this will work "most of the time," and should be
184 // sufficient... but storing away DataCollections is the "right way" to do this.
185 // We'll accomplish this via JavaScript storage of snapshots, and then we'll
186 // remove the Reset() methods. We may also need a short-term-max value in
187 // DeathData that is reset (as synchronously as possible) during each snapshot.
188 // This will facilitate displaying a max value for each snapshot period.
190 namespace tracked_objects
{
192 //------------------------------------------------------------------------------
193 // For a specific thread, and a specific birth place, the collection of all
194 // death info (with tallies for each death thread, to prevent access conflicts).
196 class BASE_EXPORT BirthOnThread
{
198 BirthOnThread(const Location
& location
, const ThreadData
& current
);
200 const Location
location() const { return location_
; }
201 const ThreadData
* birth_thread() const { return birth_thread_
; }
204 // File/lineno of birth. This defines the essence of the task, as the context
205 // of the birth (construction) often tell what the item is for. This field
206 // is const, and hence safe to access from any thread.
207 const Location location_
;
209 // The thread that records births into this object. Only this thread is
210 // allowed to update birth_count_ (which changes over time).
211 const ThreadData
* const birth_thread_
;
213 DISALLOW_COPY_AND_ASSIGN(BirthOnThread
);
216 //------------------------------------------------------------------------------
217 // A "snapshotted" representation of the BirthOnThread class.
219 struct BASE_EXPORT BirthOnThreadSnapshot
{
220 BirthOnThreadSnapshot();
221 explicit BirthOnThreadSnapshot(const BirthOnThread
& birth
);
222 ~BirthOnThreadSnapshot();
224 LocationSnapshot location
;
225 std::string thread_name
;
228 //------------------------------------------------------------------------------
229 // A class for accumulating counts of births (without bothering with a map<>).
231 class BASE_EXPORT Births
: public BirthOnThread
{
233 Births(const Location
& location
, const ThreadData
& current
);
235 int birth_count() const;
237 // When we have a birth we update the count for this birthplace.
240 // When a birthplace is changed (updated), we need to decrement the counter
241 // for the old instance.
244 // Hack to quickly reset all counts to zero.
248 // The number of births on this thread for our location_.
251 DISALLOW_COPY_AND_ASSIGN(Births
);
254 //------------------------------------------------------------------------------
255 // Basic info summarizing multiple destructions of a tracked object with a
256 // single birthplace (fixed Location). Used both on specific threads, and also
257 // in snapshots when integrating assembled data.
259 class BASE_EXPORT DeathData
{
261 // Default initializer.
264 // When deaths have not yet taken place, and we gather data from all the
265 // threads, we create DeathData stats that tally the number of births without
266 // a corresponding death.
267 explicit DeathData(int count
);
269 // Update stats for a task destruction (death) that had a Run() time of
270 // |duration|, and has had a queueing delay of |queue_duration|.
271 void RecordDeath(const int32 queue_duration
,
272 const int32 run_duration
,
275 // Metrics accessors, used only for serialization and in tests.
277 int32
run_duration_sum() const;
278 int32
run_duration_max() const;
279 int32
run_duration_sample() const;
280 int32
queue_duration_sum() const;
281 int32
queue_duration_max() const;
282 int32
queue_duration_sample() const;
284 // Reset the max values to zero.
287 // Reset all tallies to zero. This is used as a hack on realtime data.
291 // Members are ordered from most regularly read and updated, to least
292 // frequently used. This might help a bit with cache lines.
293 // Number of runs seen (divisor for calculating averages).
295 // Basic tallies, used to compute averages.
296 int32 run_duration_sum_
;
297 int32 queue_duration_sum_
;
298 // Max values, used by local visualization routines. These are often read,
299 // but rarely updated.
300 int32 run_duration_max_
;
301 int32 queue_duration_max_
;
302 // Samples, used by crowd sourcing gatherers. These are almost never read,
303 // and rarely updated.
304 int32 run_duration_sample_
;
305 int32 queue_duration_sample_
;
308 //------------------------------------------------------------------------------
309 // A "snapshotted" representation of the DeathData class.
311 struct BASE_EXPORT DeathDataSnapshot
{
313 explicit DeathDataSnapshot(const DeathData
& death_data
);
314 ~DeathDataSnapshot();
317 int32 run_duration_sum
;
318 int32 run_duration_max
;
319 int32 run_duration_sample
;
320 int32 queue_duration_sum
;
321 int32 queue_duration_max
;
322 int32 queue_duration_sample
;
325 //------------------------------------------------------------------------------
326 // A temporary collection of data that can be sorted and summarized. It is
327 // gathered (carefully) from many threads. Instances are held in arrays and
328 // processed, filtered, and rendered.
329 // The source of this data was collected on many threads, and is asynchronously
330 // changing. The data in this instance is not asynchronously changing.
332 struct BASE_EXPORT TaskSnapshot
{
334 TaskSnapshot(const BirthOnThread
& birth
,
335 const DeathData
& death_data
,
336 const std::string
& death_thread_name
);
339 BirthOnThreadSnapshot birth
;
340 DeathDataSnapshot death_data
;
341 std::string death_thread_name
;
344 //------------------------------------------------------------------------------
345 // For each thread, we have a ThreadData that stores all tracking info generated
346 // on this thread. This prevents the need for locking as data accumulates.
347 // We use ThreadLocalStorage to quickly identfy the current ThreadData context.
348 // We also have a linked list of ThreadData instances, and that list is used to
349 // harvest data from all existing instances.
351 struct ProcessDataSnapshot
;
352 class BASE_EXPORT ThreadData
{
354 // Current allowable states of the tracking system. The states can vary
355 // between ACTIVE and DEACTIVATED, but can never go back to UNINITIALIZED.
357 UNINITIALIZED
, // PRistine, link-time state before running.
358 DORMANT_DURING_TESTS
, // Only used during testing.
359 DEACTIVATED
, // No longer recording profling.
360 PROFILING_ACTIVE
, // Recording profiles (no parent-child links).
361 PROFILING_CHILDREN_ACTIVE
, // Fully active, recording parent-child links.
364 typedef std::map
<Location
, Births
*> BirthMap
;
365 typedef std::map
<const Births
*, DeathData
> DeathMap
;
366 typedef std::pair
<const Births
*, const Births
*> ParentChildPair
;
367 typedef std::set
<ParentChildPair
> ParentChildSet
;
368 typedef std::stack
<const Births
*> ParentStack
;
370 // Initialize the current thread context with a new instance of ThreadData.
371 // This is used by all threads that have names, and should be explicitly
372 // set *before* any births on the threads have taken place. It is generally
373 // only used by the message loop, which has a well defined thread name.
374 static void InitializeThreadContext(const std::string
& suggested_name
);
376 // Using Thread Local Store, find the current instance for collecting data.
377 // If an instance does not exist, construct one (and remember it for use on
379 // This may return NULL if the system is disabled for any reason.
380 static ThreadData
* Get();
382 // Fills |process_data| with all the recursive results in our process.
383 // During the scavenging, if |reset_max| is true, then the DeathData instances
384 // max-values are reset to zero during this scan.
385 static void Snapshot(bool reset_max
, ProcessDataSnapshot
* process_data
);
387 // Finds (or creates) a place to count births from the given location in this
388 // thread, and increment that tally.
389 // TallyABirthIfActive will returns NULL if the birth cannot be tallied.
390 static Births
* TallyABirthIfActive(const Location
& location
);
392 // Records the end of a timed run of an object. The |completed_task| contains
393 // a pointer to a Births, the time_posted, and a delayed_start_time if any.
394 // The |start_of_run| indicates when we started to perform the run of the
395 // task. The delayed_start_time is non-null for tasks that were posted as
396 // delayed tasks, and it indicates when the task should have run (i.e., when
397 // it should have posted out of the timer queue, and into the work queue.
398 // The |end_of_run| was just obtained by a call to Now() (just after the task
399 // finished). It is provided as an argument to help with testing.
400 static void TallyRunOnNamedThreadIfTracking(
401 const base::TrackingInfo
& completed_task
,
402 const TrackedTime
& start_of_run
,
403 const TrackedTime
& end_of_run
);
405 // Record the end of a timed run of an object. The |birth| is the record for
406 // the instance, the |time_posted| records that instant, which is presumed to
407 // be when the task was posted into a queue to run on a worker thread.
408 // The |start_of_run| is when the worker thread started to perform the run of
410 // The |end_of_run| was just obtained by a call to Now() (just after the task
412 static void TallyRunOnWorkerThreadIfTracking(
414 const TrackedTime
& time_posted
,
415 const TrackedTime
& start_of_run
,
416 const TrackedTime
& end_of_run
);
418 // Record the end of execution in region, generally corresponding to a scope
420 static void TallyRunInAScopedRegionIfTracking(
422 const TrackedTime
& start_of_run
,
423 const TrackedTime
& end_of_run
);
425 const std::string
thread_name() const;
427 // Hack: asynchronously clear all birth counts and death tallies data values
428 // in all ThreadData instances. The numerical (zeroing) part is done without
429 // use of a locks or atomics exchanges, and may (for int64 values) produce
430 // bogus counts VERY rarely.
431 static void ResetAllThreadData();
433 // Initializes all statics if needed (this initialization call should be made
434 // while we are single threaded). Returns false if unable to initialize.
435 static bool Initialize();
437 // Sets internal status_.
438 // If |status| is false, then status_ is set to DEACTIVATED.
439 // If |status| is true, then status_ is set to, PROFILING_ACTIVE, or
440 // PROFILING_CHILDREN_ACTIVE.
441 // If tracking is not compiled in, this function will return false.
442 // If parent-child tracking is not compiled in, then an attempt to set the
443 // status to PROFILING_CHILDREN_ACTIVE will only result in a status of
444 // PROFILING_ACTIVE (i.e., it can't be set to a higher level than what is
445 // compiled into the binary, and parent-child tracking at the
446 // PROFILING_CHILDREN_ACTIVE level might not be compiled in).
447 static bool InitializeAndSetTrackingStatus(Status status
);
449 static Status
status();
451 // Indicate if any sort of profiling is being done (i.e., we are more than
453 static bool TrackingStatus();
455 // For testing only, indicate if the status of parent-child tracking is turned
456 // on. This is currently a compiled option, atop TrackingStatus().
457 static bool TrackingParentChildStatus();
459 // Special versions of Now() for getting times at start and end of a tracked
460 // run. They are super fast when tracking is disabled, and have some internal
461 // side effects when we are tracking, so that we can deduce the amount of time
462 // accumulated outside of execution of tracked runs.
463 // The task that will be tracked is passed in as |parent| so that parent-child
464 // relationships can be (optionally) calculated.
465 static TrackedTime
NowForStartOfRun(const Births
* parent
);
466 static TrackedTime
NowForEndOfRun();
468 // Provide a time function that does nothing (runs fast) when we don't have
469 // the profiler enabled. It will generally be optimized away when it is
470 // ifdef'ed to be small enough (allowing the profiler to be "compiled out" of
472 static TrackedTime
Now();
474 // Use the function |now| to provide current times, instead of calling the
475 // TrackedTime::Now() function. Since this alternate function is being used,
476 // the other time arguments (used for calculating queueing delay) will be
478 static void SetAlternateTimeSource(NowFunction
* now
);
480 // This function can be called at process termination to validate that thread
481 // cleanup routines have been called for at least some number of named
483 static void EnsureCleanupWasCalled(int major_threads_shutdown_count
);
486 // Allow only tests to call ShutdownSingleThreadedCleanup. We NEVER call it
487 // in production code.
488 // TODO(jar): Make this a friend in DEBUG only, so that the optimizer has a
489 // better change of optimizing (inlining? etc.) private methods (knowing that
490 // there will be no need for an external entry point).
491 friend class TrackedObjectsTest
;
492 FRIEND_TEST_ALL_PREFIXES(TrackedObjectsTest
, MinimalStartupShutdown
);
493 FRIEND_TEST_ALL_PREFIXES(TrackedObjectsTest
, TinyStartupShutdown
);
494 FRIEND_TEST_ALL_PREFIXES(TrackedObjectsTest
, ParentChildTest
);
496 typedef std::map
<const BirthOnThread
*, int> BirthCountMap
;
498 // Worker thread construction creates a name since there is none.
499 explicit ThreadData(int thread_number
);
501 // Message loop based construction should provide a name.
502 explicit ThreadData(const std::string
& suggested_name
);
506 // Push this instance to the head of all_thread_data_list_head_, linking it to
507 // the previous head. This is performed after each construction, and leaves
508 // the instance permanently on that list.
509 void PushToHeadOfList();
511 // (Thread safe) Get start of list of all ThreadData instances using the lock.
512 static ThreadData
* first();
514 // Iterate through the null terminated list of ThreadData instances.
515 ThreadData
* next() const;
518 // In this thread's data, record a new birth.
519 Births
* TallyABirth(const Location
& location
);
521 // Find a place to record a death on this thread.
522 void TallyADeath(const Births
& birth
, int32 queue_duration
, int32 duration
);
524 // Snapshot (under a lock) the profiled data for the tasks in each ThreadData
525 // instance. Also updates the |birth_counts| tally for each task to keep
526 // track of the number of living instances of the task. If |reset_max| is
527 // true, then the max values in each DeathData instance are reset during the
529 static void SnapshotAllExecutedTasks(bool reset_max
,
530 ProcessDataSnapshot
* process_data
,
531 BirthCountMap
* birth_counts
);
533 // Snapshots (under a lock) the profiled data for the tasks for this thread
534 // and writes all of the executed tasks' data -- i.e. the data for the tasks
535 // with with entries in the death_map_ -- into |process_data|. Also updates
536 // the |birth_counts| tally for each task to keep track of the number of
537 // living instances of the task -- that is, each task maps to the number of
538 // births for the task that have not yet been balanced by a death. If
539 // |reset_max| is true, then the max values in each DeathData instance are
540 // reset during the scan.
541 void SnapshotExecutedTasks(bool reset_max
,
542 ProcessDataSnapshot
* process_data
,
543 BirthCountMap
* birth_counts
);
545 // Using our lock, make a copy of the specified maps. This call may be made
546 // on non-local threads, which necessitate the use of the lock to prevent
547 // the map(s) from being reallocaed while they are copied. If |reset_max| is
548 // true, then, just after we copy the DeathMap, we will set the max values to
549 // zero in the active DeathMap (not the snapshot).
550 void SnapshotMaps(bool reset_max
,
553 ParentChildSet
* parent_child_set
);
555 // Using our lock to protect the iteration, Clear all birth and death data.
558 // This method is called by the TLS system when a thread terminates.
559 // The argument may be NULL if this thread has never tracked a birth or death.
560 static void OnThreadTermination(void* thread_data
);
562 // This method should be called when a worker thread terminates, so that we
563 // can save all the thread data into a cache of reusable ThreadData instances.
564 void OnThreadTerminationCleanup();
566 // Cleans up data structures, and returns statics to near pristine (mostly
567 // uninitialized) state. If there is any chance that other threads are still
568 // using the data structures, then the |leak| argument should be passed in as
569 // true, and the data structures (birth maps, death maps, ThreadData
570 // insntances, etc.) will be leaked and not deleted. If you have joined all
571 // threads since the time that InitializeAndSetTrackingStatus() was called,
572 // then you can pass in a |leak| value of false, and this function will
573 // delete recursively all data structures, starting with the list of
574 // ThreadData instances.
575 static void ShutdownSingleThreadedCleanup(bool leak
);
577 // When non-null, this specifies an external function that supplies monotone
578 // increasing time functcion.
579 static NowFunction
* now_function_
;
581 // We use thread local store to identify which ThreadData to interact with.
582 static base::ThreadLocalStorage::StaticSlot tls_index_
;
584 // List of ThreadData instances for use with worker threads. When a worker
585 // thread is done (terminated), we push it onto this llist. When a new worker
586 // thread is created, we first try to re-use a ThreadData instance from the
587 // list, and if none are available, construct a new one.
588 // This is only accessed while list_lock_ is held.
589 static ThreadData
* first_retired_worker_
;
591 // Link to the most recently created instance (starts a null terminated list).
592 // The list is traversed by about:profiler when it needs to snapshot data.
593 // This is only accessed while list_lock_ is held.
594 static ThreadData
* all_thread_data_list_head_
;
596 // The next available worker thread number. This should only be accessed when
597 // the list_lock_ is held.
598 static int worker_thread_data_creation_count_
;
600 // The number of times TLS has called us back to cleanup a ThreadData
601 // instance. This is only accessed while list_lock_ is held.
602 static int cleanup_count_
;
604 // Incarnation sequence number, indicating how many times (during unittests)
605 // we've either transitioned out of UNINITIALIZED, or into that state. This
606 // value is only accessed while the list_lock_ is held.
607 static int incarnation_counter_
;
609 // Protection for access to all_thread_data_list_head_, and to
610 // unregistered_thread_data_pool_. This lock is leaked at shutdown.
611 // The lock is very infrequently used, so we can afford to just make a lazy
612 // instance and be safe.
613 static base::LazyInstance
<base::Lock
>::Leaky list_lock_
;
615 // We set status_ to SHUTDOWN when we shut down the tracking service.
616 static Status status_
;
618 // Link to next instance (null terminated list). Used to globally track all
619 // registered instances (corresponds to all registered threads where we keep
623 // Pointer to another ThreadData instance for a Worker-Thread that has been
624 // retired (its thread was terminated). This value is non-NULL only for a
625 // retired ThreadData associated with a Worker-Thread.
626 ThreadData
* next_retired_worker_
;
628 // The name of the thread that is being recorded. If this thread has no
629 // message_loop, then this is a worker thread, with a sequence number postfix.
630 std::string thread_name_
;
632 // Indicate if this is a worker thread, and the ThreadData contexts should be
633 // stored in the unregistered_thread_data_pool_ when not in use.
634 // Value is zero when it is not a worker thread. Value is a positive integer
635 // corresponding to the created thread name if it is a worker thread.
636 int worker_thread_number_
;
638 // A map used on each thread to keep track of Births on this thread.
639 // This map should only be accessed on the thread it was constructed on.
640 // When a snapshot is needed, this structure can be locked in place for the
641 // duration of the snapshotting activity.
644 // Similar to birth_map_, this records informations about death of tracked
645 // instances (i.e., when a tracked instance was destroyed on this thread).
646 // It is locked before changing, and hence other threads may access it by
647 // locking before reading it.
650 // A set of parents that created children tasks on this thread. Each pair
651 // corresponds to potentially non-local Births (location and thread), and a
652 // local Births (that took place on this thread).
653 ParentChildSet parent_child_set_
;
655 // Lock to protect *some* access to BirthMap and DeathMap. The maps are
656 // regularly read and written on this thread, but may only be read from other
657 // threads. To support this, we acquire this lock if we are writing from this
658 // thread, or reading from another thread. For reading from this thread we
659 // don't need a lock, as there is no potential for a conflict since the
660 // writing is only done from this thread.
661 mutable base::Lock map_lock_
;
663 // The stack of parents that are currently being profiled. This includes only
664 // tasks that have started a timer recently via NowForStartOfRun(), but not
665 // yet concluded with a NowForEndOfRun(). Usually this stack is one deep, but
666 // if a scoped region is profiled, or <sigh> a task runs a nested-message
667 // loop, then the stack can grow larger. Note that we don't try to deduct
668 // time in nested porfiles, as our current timer is based on wall-clock time,
669 // and not CPU time (and we're hopeful that nested timing won't be a
670 // significant additional cost).
671 ParentStack parent_stack_
;
673 // A random number that we used to select decide which sample to keep as a
674 // representative sample in each DeathData instance. We can't start off with
675 // much randomness (because we can't call RandInt() on all our threads), so
676 // we stir in more and more as we go.
677 int32 random_number_
;
679 // Record of what the incarnation_counter_ was when this instance was created.
680 // If the incarnation_counter_ has changed, then we avoid pushing into the
681 // pool (this is only critical in tests which go through multiple
683 int incarnation_count_for_pool_
;
685 DISALLOW_COPY_AND_ASSIGN(ThreadData
);
688 //------------------------------------------------------------------------------
689 // A snapshotted representation of a (parent, child) task pair, for tracking
690 // hierarchical profiles.
692 struct BASE_EXPORT ParentChildPairSnapshot
{
694 ParentChildPairSnapshot();
695 explicit ParentChildPairSnapshot(
696 const ThreadData::ParentChildPair
& parent_child
);
697 ~ParentChildPairSnapshot();
699 BirthOnThreadSnapshot parent
;
700 BirthOnThreadSnapshot child
;
703 //------------------------------------------------------------------------------
704 // A snapshotted representation of the list of ThreadData objects for a process.
706 struct BASE_EXPORT ProcessDataSnapshot
{
708 ProcessDataSnapshot();
709 ~ProcessDataSnapshot();
711 std::vector
<TaskSnapshot
> tasks
;
712 std::vector
<ParentChildPairSnapshot
> descendants
;
716 } // namespace tracked_objects
718 #endif // BASE_TRACKED_OBJECTS_H_