Don't leave aborted URLs in the omnibox unless we're on the NTP.
[chromium-blink-merge.git] / base / tracked_objects.cc
blob56b44c10b2c389fbb053bee442769c0eda51941a
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 #include "base/tracked_objects.h"
7 #include <limits.h>
8 #include <stdlib.h>
10 #include "base/atomicops.h"
11 #include "base/base_switches.h"
12 #include "base/command_line.h"
13 #include "base/compiler_specific.h"
14 #include "base/debug/leak_annotations.h"
15 #include "base/logging.h"
16 #include "base/process/process_handle.h"
17 #include "base/profiler/alternate_timer.h"
18 #include "base/strings/stringprintf.h"
19 #include "base/third_party/valgrind/memcheck.h"
20 #include "base/tracking_info.h"
22 using base::TimeDelta;
24 namespace base {
25 class TimeDelta;
28 namespace tracked_objects {
30 namespace {
31 // Flag to compile out almost all of the task tracking code.
32 const bool kTrackAllTaskObjects = true;
34 // TODO(jar): Evaluate the perf impact of enabling this. If the perf impact is
35 // negligible, enable by default.
36 // Flag to compile out parent-child link recording.
37 const bool kTrackParentChildLinks = false;
39 // When ThreadData is first initialized, should we start in an ACTIVE state to
40 // record all of the startup-time tasks, or should we start up DEACTIVATED, so
41 // that we only record after parsing the command line flag --enable-tracking.
42 // Note that the flag may force either state, so this really controls only the
43 // period of time up until that flag is parsed. If there is no flag seen, then
44 // this state may prevail for much or all of the process lifetime.
45 const ThreadData::Status kInitialStartupState =
46 ThreadData::PROFILING_CHILDREN_ACTIVE;
48 // Control whether an alternate time source (Now() function) is supported by
49 // the ThreadData class. This compile time flag should be set to true if we
50 // want other modules (such as a memory allocator, or a thread-specific CPU time
51 // clock) to be able to provide a thread-specific Now() function. Without this
52 // compile-time flag, the code will only support the wall-clock time. This flag
53 // can be flipped to efficiently disable this path (if there is a performance
54 // problem with its presence).
55 static const bool kAllowAlternateTimeSourceHandling = true;
57 inline bool IsProfilerTimingEnabled() {
58 enum {
59 UNDEFINED_TIMING,
60 ENABLED_TIMING,
61 DISABLED_TIMING,
63 static base::subtle::Atomic32 timing_enabled = UNDEFINED_TIMING;
64 // Reading |timing_enabled| is done without barrier because multiple
65 // initialization is not an issue while the barrier can be relatively costly
66 // given that this method is sometimes called in a tight loop.
67 base::subtle::Atomic32 current_timing_enabled =
68 base::subtle::NoBarrier_Load(&timing_enabled);
69 if (current_timing_enabled == UNDEFINED_TIMING) {
70 if (!CommandLine::InitializedForCurrentProcess())
71 return true;
72 current_timing_enabled =
73 (CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
74 switches::kProfilerTiming) ==
75 switches::kProfilerTimingDisabledValue)
76 ? DISABLED_TIMING
77 : ENABLED_TIMING;
78 base::subtle::NoBarrier_Store(&timing_enabled, current_timing_enabled);
80 return current_timing_enabled == ENABLED_TIMING;
83 } // namespace
85 //------------------------------------------------------------------------------
86 // DeathData tallies durations when a death takes place.
88 DeathData::DeathData() {
89 Clear();
92 DeathData::DeathData(int count) {
93 Clear();
94 count_ = count;
97 // TODO(jar): I need to see if this macro to optimize branching is worth using.
99 // This macro has no branching, so it is surely fast, and is equivalent to:
100 // if (assign_it)
101 // target = source;
102 // We use a macro rather than a template to force this to inline.
103 // Related code for calculating max is discussed on the web.
104 #define CONDITIONAL_ASSIGN(assign_it, target, source) \
105 ((target) ^= ((target) ^ (source)) & -static_cast<int32>(assign_it))
107 void DeathData::RecordDeath(const int32 queue_duration,
108 const int32 run_duration,
109 int32 random_number) {
110 // We'll just clamp at INT_MAX, but we should note this in the UI as such.
111 if (count_ < INT_MAX)
112 ++count_;
113 queue_duration_sum_ += queue_duration;
114 run_duration_sum_ += run_duration;
116 if (queue_duration_max_ < queue_duration)
117 queue_duration_max_ = queue_duration;
118 if (run_duration_max_ < run_duration)
119 run_duration_max_ = run_duration;
121 // Take a uniformly distributed sample over all durations ever supplied.
122 // The probability that we (instead) use this new sample is 1/count_. This
123 // results in a completely uniform selection of the sample (at least when we
124 // don't clamp count_... but that should be inconsequentially likely).
125 // We ignore the fact that we correlated our selection of a sample to the run
126 // and queue times (i.e., we used them to generate random_number).
127 CHECK_GT(count_, 0);
128 if (0 == (random_number % count_)) {
129 queue_duration_sample_ = queue_duration;
130 run_duration_sample_ = run_duration;
134 int DeathData::count() const { return count_; }
136 int32 DeathData::run_duration_sum() const { return run_duration_sum_; }
138 int32 DeathData::run_duration_max() const { return run_duration_max_; }
140 int32 DeathData::run_duration_sample() const {
141 return run_duration_sample_;
144 int32 DeathData::queue_duration_sum() const {
145 return queue_duration_sum_;
148 int32 DeathData::queue_duration_max() const {
149 return queue_duration_max_;
152 int32 DeathData::queue_duration_sample() const {
153 return queue_duration_sample_;
156 void DeathData::ResetMax() {
157 run_duration_max_ = 0;
158 queue_duration_max_ = 0;
161 void DeathData::Clear() {
162 count_ = 0;
163 run_duration_sum_ = 0;
164 run_duration_max_ = 0;
165 run_duration_sample_ = 0;
166 queue_duration_sum_ = 0;
167 queue_duration_max_ = 0;
168 queue_duration_sample_ = 0;
171 //------------------------------------------------------------------------------
172 DeathDataSnapshot::DeathDataSnapshot()
173 : count(-1),
174 run_duration_sum(-1),
175 run_duration_max(-1),
176 run_duration_sample(-1),
177 queue_duration_sum(-1),
178 queue_duration_max(-1),
179 queue_duration_sample(-1) {
182 DeathDataSnapshot::DeathDataSnapshot(
183 const tracked_objects::DeathData& death_data)
184 : count(death_data.count()),
185 run_duration_sum(death_data.run_duration_sum()),
186 run_duration_max(death_data.run_duration_max()),
187 run_duration_sample(death_data.run_duration_sample()),
188 queue_duration_sum(death_data.queue_duration_sum()),
189 queue_duration_max(death_data.queue_duration_max()),
190 queue_duration_sample(death_data.queue_duration_sample()) {
193 DeathDataSnapshot::~DeathDataSnapshot() {
196 //------------------------------------------------------------------------------
197 BirthOnThread::BirthOnThread(const Location& location,
198 const ThreadData& current)
199 : location_(location),
200 birth_thread_(&current) {
203 //------------------------------------------------------------------------------
204 BirthOnThreadSnapshot::BirthOnThreadSnapshot() {
207 BirthOnThreadSnapshot::BirthOnThreadSnapshot(
208 const tracked_objects::BirthOnThread& birth)
209 : location(birth.location()),
210 thread_name(birth.birth_thread()->thread_name()) {
213 BirthOnThreadSnapshot::~BirthOnThreadSnapshot() {
216 //------------------------------------------------------------------------------
217 Births::Births(const Location& location, const ThreadData& current)
218 : BirthOnThread(location, current),
219 birth_count_(1) { }
221 int Births::birth_count() const { return birth_count_; }
223 void Births::RecordBirth() { ++birth_count_; }
225 void Births::ForgetBirth() { --birth_count_; }
227 void Births::Clear() { birth_count_ = 0; }
229 //------------------------------------------------------------------------------
230 // ThreadData maintains the central data for all births and deaths on a single
231 // thread.
233 // TODO(jar): We should pull all these static vars together, into a struct, and
234 // optimize layout so that we benefit from locality of reference during accesses
235 // to them.
237 // static
238 NowFunction* ThreadData::now_function_ = NULL;
240 // A TLS slot which points to the ThreadData instance for the current thread. We
241 // do a fake initialization here (zeroing out data), and then the real in-place
242 // construction happens when we call tls_index_.Initialize().
243 // static
244 base::ThreadLocalStorage::StaticSlot ThreadData::tls_index_ = TLS_INITIALIZER;
246 // static
247 int ThreadData::worker_thread_data_creation_count_ = 0;
249 // static
250 int ThreadData::cleanup_count_ = 0;
252 // static
253 int ThreadData::incarnation_counter_ = 0;
255 // static
256 ThreadData* ThreadData::all_thread_data_list_head_ = NULL;
258 // static
259 ThreadData* ThreadData::first_retired_worker_ = NULL;
261 // static
262 base::LazyInstance<base::Lock>::Leaky
263 ThreadData::list_lock_ = LAZY_INSTANCE_INITIALIZER;
265 // static
266 ThreadData::Status ThreadData::status_ = ThreadData::UNINITIALIZED;
268 ThreadData::ThreadData(const std::string& suggested_name)
269 : next_(NULL),
270 next_retired_worker_(NULL),
271 worker_thread_number_(0),
272 incarnation_count_for_pool_(-1) {
273 DCHECK_GE(suggested_name.size(), 0u);
274 thread_name_ = suggested_name;
275 PushToHeadOfList(); // Which sets real incarnation_count_for_pool_.
278 ThreadData::ThreadData(int thread_number)
279 : next_(NULL),
280 next_retired_worker_(NULL),
281 worker_thread_number_(thread_number),
282 incarnation_count_for_pool_(-1) {
283 CHECK_GT(thread_number, 0);
284 base::StringAppendF(&thread_name_, "WorkerThread-%d", thread_number);
285 PushToHeadOfList(); // Which sets real incarnation_count_for_pool_.
288 ThreadData::~ThreadData() {}
290 void ThreadData::PushToHeadOfList() {
291 // Toss in a hint of randomness (atop the uniniitalized value).
292 (void)VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE(&random_number_,
293 sizeof(random_number_));
294 MSAN_UNPOISON(&random_number_, sizeof(random_number_));
295 random_number_ += static_cast<int32>(this - static_cast<ThreadData*>(0));
296 random_number_ ^= (Now() - TrackedTime()).InMilliseconds();
298 DCHECK(!next_);
299 base::AutoLock lock(*list_lock_.Pointer());
300 incarnation_count_for_pool_ = incarnation_counter_;
301 next_ = all_thread_data_list_head_;
302 all_thread_data_list_head_ = this;
305 // static
306 ThreadData* ThreadData::first() {
307 base::AutoLock lock(*list_lock_.Pointer());
308 return all_thread_data_list_head_;
311 ThreadData* ThreadData::next() const { return next_; }
313 // static
314 void ThreadData::InitializeThreadContext(const std::string& suggested_name) {
315 if (!Initialize()) // Always initialize if needed.
316 return;
317 ThreadData* current_thread_data =
318 reinterpret_cast<ThreadData*>(tls_index_.Get());
319 if (current_thread_data)
320 return; // Browser tests instigate this.
321 current_thread_data = new ThreadData(suggested_name);
322 tls_index_.Set(current_thread_data);
325 // static
326 ThreadData* ThreadData::Get() {
327 if (!tls_index_.initialized())
328 return NULL; // For unittests only.
329 ThreadData* registered = reinterpret_cast<ThreadData*>(tls_index_.Get());
330 if (registered)
331 return registered;
333 // We must be a worker thread, since we didn't pre-register.
334 ThreadData* worker_thread_data = NULL;
335 int worker_thread_number = 0;
337 base::AutoLock lock(*list_lock_.Pointer());
338 if (first_retired_worker_) {
339 worker_thread_data = first_retired_worker_;
340 first_retired_worker_ = first_retired_worker_->next_retired_worker_;
341 worker_thread_data->next_retired_worker_ = NULL;
342 } else {
343 worker_thread_number = ++worker_thread_data_creation_count_;
347 // If we can't find a previously used instance, then we have to create one.
348 if (!worker_thread_data) {
349 DCHECK_GT(worker_thread_number, 0);
350 worker_thread_data = new ThreadData(worker_thread_number);
352 DCHECK_GT(worker_thread_data->worker_thread_number_, 0);
354 tls_index_.Set(worker_thread_data);
355 return worker_thread_data;
358 // static
359 void ThreadData::OnThreadTermination(void* thread_data) {
360 DCHECK(thread_data); // TLS should *never* call us with a NULL.
361 // We must NOT do any allocations during this callback. There is a chance
362 // that the allocator is no longer active on this thread.
363 if (!kTrackAllTaskObjects)
364 return; // Not compiled in.
365 reinterpret_cast<ThreadData*>(thread_data)->OnThreadTerminationCleanup();
368 void ThreadData::OnThreadTerminationCleanup() {
369 // The list_lock_ was created when we registered the callback, so it won't be
370 // allocated here despite the lazy reference.
371 base::AutoLock lock(*list_lock_.Pointer());
372 if (incarnation_counter_ != incarnation_count_for_pool_)
373 return; // ThreadData was constructed in an earlier unit test.
374 ++cleanup_count_;
375 // Only worker threads need to be retired and reused.
376 if (!worker_thread_number_) {
377 return;
379 // We must NOT do any allocations during this callback.
380 // Using the simple linked lists avoids all allocations.
381 DCHECK_EQ(this->next_retired_worker_, reinterpret_cast<ThreadData*>(NULL));
382 this->next_retired_worker_ = first_retired_worker_;
383 first_retired_worker_ = this;
386 // static
387 void ThreadData::Snapshot(bool reset_max, ProcessDataSnapshot* process_data) {
388 // Add births that have run to completion to |collected_data|.
389 // |birth_counts| tracks the total number of births recorded at each location
390 // for which we have not seen a death count.
391 BirthCountMap birth_counts;
392 ThreadData::SnapshotAllExecutedTasks(reset_max, process_data, &birth_counts);
394 // Add births that are still active -- i.e. objects that have tallied a birth,
395 // but have not yet tallied a matching death, and hence must be either
396 // running, queued up, or being held in limbo for future posting.
397 for (BirthCountMap::const_iterator it = birth_counts.begin();
398 it != birth_counts.end(); ++it) {
399 if (it->second > 0) {
400 process_data->tasks.push_back(
401 TaskSnapshot(*it->first, DeathData(it->second), "Still_Alive"));
406 Births* ThreadData::TallyABirth(const Location& location) {
407 BirthMap::iterator it = birth_map_.find(location);
408 Births* child;
409 if (it != birth_map_.end()) {
410 child = it->second;
411 child->RecordBirth();
412 } else {
413 child = new Births(location, *this); // Leak this.
414 // Lock since the map may get relocated now, and other threads sometimes
415 // snapshot it (but they lock before copying it).
416 base::AutoLock lock(map_lock_);
417 birth_map_[location] = child;
420 if (kTrackParentChildLinks && status_ > PROFILING_ACTIVE &&
421 !parent_stack_.empty()) {
422 const Births* parent = parent_stack_.top();
423 ParentChildPair pair(parent, child);
424 if (parent_child_set_.find(pair) == parent_child_set_.end()) {
425 // Lock since the map may get relocated now, and other threads sometimes
426 // snapshot it (but they lock before copying it).
427 base::AutoLock lock(map_lock_);
428 parent_child_set_.insert(pair);
432 return child;
435 void ThreadData::TallyADeath(const Births& birth,
436 int32 queue_duration,
437 int32 run_duration) {
438 // Stir in some randomness, plus add constant in case durations are zero.
439 const int32 kSomePrimeNumber = 2147483647;
440 random_number_ += queue_duration + run_duration + kSomePrimeNumber;
441 // An address is going to have some randomness to it as well ;-).
442 random_number_ ^= static_cast<int32>(&birth - reinterpret_cast<Births*>(0));
444 // We don't have queue durations without OS timer. OS timer is automatically
445 // used for task-post-timing, so the use of an alternate timer implies all
446 // queue times are invalid.
447 if (kAllowAlternateTimeSourceHandling && now_function_)
448 queue_duration = 0;
450 DeathMap::iterator it = death_map_.find(&birth);
451 DeathData* death_data;
452 if (it != death_map_.end()) {
453 death_data = &it->second;
454 } else {
455 base::AutoLock lock(map_lock_); // Lock as the map may get relocated now.
456 death_data = &death_map_[&birth];
457 } // Release lock ASAP.
458 death_data->RecordDeath(queue_duration, run_duration, random_number_);
460 if (!kTrackParentChildLinks)
461 return;
462 if (!parent_stack_.empty()) { // We might get turned off.
463 DCHECK_EQ(parent_stack_.top(), &birth);
464 parent_stack_.pop();
468 // static
469 Births* ThreadData::TallyABirthIfActive(const Location& location) {
470 if (!kTrackAllTaskObjects)
471 return NULL; // Not compiled in.
473 if (!TrackingStatus())
474 return NULL;
475 ThreadData* current_thread_data = Get();
476 if (!current_thread_data)
477 return NULL;
478 return current_thread_data->TallyABirth(location);
481 // static
482 void ThreadData::TallyRunOnNamedThreadIfTracking(
483 const base::TrackingInfo& completed_task,
484 const TrackedTime& start_of_run,
485 const TrackedTime& end_of_run) {
486 if (!kTrackAllTaskObjects)
487 return; // Not compiled in.
489 // Even if we have been DEACTIVATED, we will process any pending births so
490 // that our data structures (which counted the outstanding births) remain
491 // consistent.
492 const Births* birth = completed_task.birth_tally;
493 if (!birth)
494 return;
495 ThreadData* current_thread_data = Get();
496 if (!current_thread_data)
497 return;
499 // Watch out for a race where status_ is changing, and hence one or both
500 // of start_of_run or end_of_run is zero. In that case, we didn't bother to
501 // get a time value since we "weren't tracking" and we were trying to be
502 // efficient by not calling for a genuine time value. For simplicity, we'll
503 // use a default zero duration when we can't calculate a true value.
504 int32 queue_duration = 0;
505 int32 run_duration = 0;
506 if (!start_of_run.is_null()) {
507 queue_duration = (start_of_run - completed_task.EffectiveTimePosted())
508 .InMilliseconds();
509 if (!end_of_run.is_null())
510 run_duration = (end_of_run - start_of_run).InMilliseconds();
512 current_thread_data->TallyADeath(*birth, queue_duration, run_duration);
515 // static
516 void ThreadData::TallyRunOnWorkerThreadIfTracking(
517 const Births* birth,
518 const TrackedTime& time_posted,
519 const TrackedTime& start_of_run,
520 const TrackedTime& end_of_run) {
521 if (!kTrackAllTaskObjects)
522 return; // Not compiled in.
524 // Even if we have been DEACTIVATED, we will process any pending births so
525 // that our data structures (which counted the outstanding births) remain
526 // consistent.
527 if (!birth)
528 return;
530 // TODO(jar): Support the option to coalesce all worker-thread activity under
531 // one ThreadData instance that uses locks to protect *all* access. This will
532 // reduce memory (making it provably bounded), but run incrementally slower
533 // (since we'll use locks on TallyABirth and TallyADeath). The good news is
534 // that the locks on TallyADeath will be *after* the worker thread has run,
535 // and hence nothing will be waiting for the completion (... besides some
536 // other thread that might like to run). Also, the worker threads tasks are
537 // generally longer, and hence the cost of the lock may perchance be amortized
538 // over the long task's lifetime.
539 ThreadData* current_thread_data = Get();
540 if (!current_thread_data)
541 return;
543 int32 queue_duration = 0;
544 int32 run_duration = 0;
545 if (!start_of_run.is_null()) {
546 queue_duration = (start_of_run - time_posted).InMilliseconds();
547 if (!end_of_run.is_null())
548 run_duration = (end_of_run - start_of_run).InMilliseconds();
550 current_thread_data->TallyADeath(*birth, queue_duration, run_duration);
553 // static
554 void ThreadData::TallyRunInAScopedRegionIfTracking(
555 const Births* birth,
556 const TrackedTime& start_of_run,
557 const TrackedTime& end_of_run) {
558 if (!kTrackAllTaskObjects)
559 return; // Not compiled in.
561 // Even if we have been DEACTIVATED, we will process any pending births so
562 // that our data structures (which counted the outstanding births) remain
563 // consistent.
564 if (!birth)
565 return;
567 ThreadData* current_thread_data = Get();
568 if (!current_thread_data)
569 return;
571 int32 queue_duration = 0;
572 int32 run_duration = 0;
573 if (!start_of_run.is_null() && !end_of_run.is_null())
574 run_duration = (end_of_run - start_of_run).InMilliseconds();
575 current_thread_data->TallyADeath(*birth, queue_duration, run_duration);
578 // static
579 void ThreadData::SnapshotAllExecutedTasks(bool reset_max,
580 ProcessDataSnapshot* process_data,
581 BirthCountMap* birth_counts) {
582 if (!kTrackAllTaskObjects)
583 return; // Not compiled in.
585 // Get an unchanging copy of a ThreadData list.
586 ThreadData* my_list = ThreadData::first();
588 // Gather data serially.
589 // This hackish approach *can* get some slighly corrupt tallies, as we are
590 // grabbing values without the protection of a lock, but it has the advantage
591 // of working even with threads that don't have message loops. If a user
592 // sees any strangeness, they can always just run their stats gathering a
593 // second time.
594 for (ThreadData* thread_data = my_list;
595 thread_data;
596 thread_data = thread_data->next()) {
597 thread_data->SnapshotExecutedTasks(reset_max, process_data, birth_counts);
601 void ThreadData::SnapshotExecutedTasks(bool reset_max,
602 ProcessDataSnapshot* process_data,
603 BirthCountMap* birth_counts) {
604 // Get copy of data, so that the data will not change during the iterations
605 // and processing.
606 ThreadData::BirthMap birth_map;
607 ThreadData::DeathMap death_map;
608 ThreadData::ParentChildSet parent_child_set;
609 SnapshotMaps(reset_max, &birth_map, &death_map, &parent_child_set);
611 for (ThreadData::DeathMap::const_iterator it = death_map.begin();
612 it != death_map.end(); ++it) {
613 process_data->tasks.push_back(
614 TaskSnapshot(*it->first, it->second, thread_name()));
615 (*birth_counts)[it->first] -= it->first->birth_count();
618 for (ThreadData::BirthMap::const_iterator it = birth_map.begin();
619 it != birth_map.end(); ++it) {
620 (*birth_counts)[it->second] += it->second->birth_count();
623 if (!kTrackParentChildLinks)
624 return;
626 for (ThreadData::ParentChildSet::const_iterator it = parent_child_set.begin();
627 it != parent_child_set.end(); ++it) {
628 process_data->descendants.push_back(ParentChildPairSnapshot(*it));
632 // This may be called from another thread.
633 void ThreadData::SnapshotMaps(bool reset_max,
634 BirthMap* birth_map,
635 DeathMap* death_map,
636 ParentChildSet* parent_child_set) {
637 base::AutoLock lock(map_lock_);
638 for (BirthMap::const_iterator it = birth_map_.begin();
639 it != birth_map_.end(); ++it)
640 (*birth_map)[it->first] = it->second;
641 for (DeathMap::iterator it = death_map_.begin();
642 it != death_map_.end(); ++it) {
643 (*death_map)[it->first] = it->second;
644 if (reset_max)
645 it->second.ResetMax();
648 if (!kTrackParentChildLinks)
649 return;
651 for (ParentChildSet::iterator it = parent_child_set_.begin();
652 it != parent_child_set_.end(); ++it)
653 parent_child_set->insert(*it);
656 // static
657 void ThreadData::ResetAllThreadData() {
658 ThreadData* my_list = first();
660 for (ThreadData* thread_data = my_list;
661 thread_data;
662 thread_data = thread_data->next())
663 thread_data->Reset();
666 void ThreadData::Reset() {
667 base::AutoLock lock(map_lock_);
668 for (DeathMap::iterator it = death_map_.begin();
669 it != death_map_.end(); ++it)
670 it->second.Clear();
671 for (BirthMap::iterator it = birth_map_.begin();
672 it != birth_map_.end(); ++it)
673 it->second->Clear();
676 static void OptionallyInitializeAlternateTimer() {
677 NowFunction* alternate_time_source = GetAlternateTimeSource();
678 if (alternate_time_source)
679 ThreadData::SetAlternateTimeSource(alternate_time_source);
682 bool ThreadData::Initialize() {
683 if (!kTrackAllTaskObjects)
684 return false; // Not compiled in.
685 if (status_ >= DEACTIVATED)
686 return true; // Someone else did the initialization.
687 // Due to racy lazy initialization in tests, we'll need to recheck status_
688 // after we acquire the lock.
690 // Ensure that we don't double initialize tls. We are called when single
691 // threaded in the product, but some tests may be racy and lazy about our
692 // initialization.
693 base::AutoLock lock(*list_lock_.Pointer());
694 if (status_ >= DEACTIVATED)
695 return true; // Someone raced in here and beat us.
697 // Put an alternate timer in place if the environment calls for it, such as
698 // for tracking TCMalloc allocations. This insertion is idempotent, so we
699 // don't mind if there is a race, and we'd prefer not to be in a lock while
700 // doing this work.
701 if (kAllowAlternateTimeSourceHandling)
702 OptionallyInitializeAlternateTimer();
704 // Perform the "real" TLS initialization now, and leave it intact through
705 // process termination.
706 if (!tls_index_.initialized()) { // Testing may have initialized this.
707 DCHECK_EQ(status_, UNINITIALIZED);
708 tls_index_.Initialize(&ThreadData::OnThreadTermination);
709 if (!tls_index_.initialized())
710 return false;
711 } else {
712 // TLS was initialzed for us earlier.
713 DCHECK_EQ(status_, DORMANT_DURING_TESTS);
716 // Incarnation counter is only significant to testing, as it otherwise will
717 // never again change in this process.
718 ++incarnation_counter_;
720 // The lock is not critical for setting status_, but it doesn't hurt. It also
721 // ensures that if we have a racy initialization, that we'll bail as soon as
722 // we get the lock earlier in this method.
723 status_ = kInitialStartupState;
724 if (!kTrackParentChildLinks &&
725 kInitialStartupState == PROFILING_CHILDREN_ACTIVE)
726 status_ = PROFILING_ACTIVE;
727 DCHECK(status_ != UNINITIALIZED);
728 return true;
731 // static
732 bool ThreadData::InitializeAndSetTrackingStatus(Status status) {
733 DCHECK_GE(status, DEACTIVATED);
734 DCHECK_LE(status, PROFILING_CHILDREN_ACTIVE);
736 if (!Initialize()) // No-op if already initialized.
737 return false; // Not compiled in.
739 if (!kTrackParentChildLinks && status > DEACTIVATED)
740 status = PROFILING_ACTIVE;
741 status_ = status;
742 return true;
745 // static
746 ThreadData::Status ThreadData::status() {
747 return status_;
750 // static
751 bool ThreadData::TrackingStatus() {
752 return status_ > DEACTIVATED;
755 // static
756 bool ThreadData::TrackingParentChildStatus() {
757 return status_ >= PROFILING_CHILDREN_ACTIVE;
760 // static
761 TrackedTime ThreadData::NowForStartOfRun(const Births* parent) {
762 if (kTrackParentChildLinks && parent && status_ > PROFILING_ACTIVE) {
763 ThreadData* current_thread_data = Get();
764 if (current_thread_data)
765 current_thread_data->parent_stack_.push(parent);
767 return Now();
770 // static
771 TrackedTime ThreadData::NowForEndOfRun() {
772 return Now();
775 // static
776 void ThreadData::SetAlternateTimeSource(NowFunction* now_function) {
777 DCHECK(now_function);
778 if (kAllowAlternateTimeSourceHandling)
779 now_function_ = now_function;
782 // static
783 TrackedTime ThreadData::Now() {
784 if (kAllowAlternateTimeSourceHandling && now_function_)
785 return TrackedTime::FromMilliseconds((*now_function_)());
786 if (kTrackAllTaskObjects && IsProfilerTimingEnabled() && TrackingStatus())
787 return TrackedTime::Now();
788 return TrackedTime(); // Super fast when disabled, or not compiled.
791 // static
792 void ThreadData::EnsureCleanupWasCalled(int major_threads_shutdown_count) {
793 base::AutoLock lock(*list_lock_.Pointer());
794 if (worker_thread_data_creation_count_ == 0)
795 return; // We haven't really run much, and couldn't have leaked.
797 // TODO(jar): until this is working on XP, don't run the real test.
798 #if 0
799 // Verify that we've at least shutdown/cleanup the major namesd threads. The
800 // caller should tell us how many thread shutdowns should have taken place by
801 // now.
802 CHECK_GT(cleanup_count_, major_threads_shutdown_count);
803 #endif
806 // static
807 void ThreadData::ShutdownSingleThreadedCleanup(bool leak) {
808 // This is only called from test code, where we need to cleanup so that
809 // additional tests can be run.
810 // We must be single threaded... but be careful anyway.
811 if (!InitializeAndSetTrackingStatus(DEACTIVATED))
812 return;
813 ThreadData* thread_data_list;
815 base::AutoLock lock(*list_lock_.Pointer());
816 thread_data_list = all_thread_data_list_head_;
817 all_thread_data_list_head_ = NULL;
818 ++incarnation_counter_;
819 // To be clean, break apart the retired worker list (though we leak them).
820 while (first_retired_worker_) {
821 ThreadData* worker = first_retired_worker_;
822 CHECK_GT(worker->worker_thread_number_, 0);
823 first_retired_worker_ = worker->next_retired_worker_;
824 worker->next_retired_worker_ = NULL;
828 // Put most global static back in pristine shape.
829 worker_thread_data_creation_count_ = 0;
830 cleanup_count_ = 0;
831 tls_index_.Set(NULL);
832 status_ = DORMANT_DURING_TESTS; // Almost UNINITIALIZED.
834 // To avoid any chance of racing in unit tests, which is the only place we
835 // call this function, we may sometimes leak all the data structures we
836 // recovered, as they may still be in use on threads from prior tests!
837 if (leak) {
838 ThreadData* thread_data = thread_data_list;
839 while (thread_data) {
840 ANNOTATE_LEAKING_OBJECT_PTR(thread_data);
841 thread_data = thread_data->next();
843 return;
846 // When we want to cleanup (on a single thread), here is what we do.
848 // Do actual recursive delete in all ThreadData instances.
849 while (thread_data_list) {
850 ThreadData* next_thread_data = thread_data_list;
851 thread_data_list = thread_data_list->next();
853 for (BirthMap::iterator it = next_thread_data->birth_map_.begin();
854 next_thread_data->birth_map_.end() != it; ++it)
855 delete it->second; // Delete the Birth Records.
856 delete next_thread_data; // Includes all Death Records.
860 //------------------------------------------------------------------------------
861 TaskSnapshot::TaskSnapshot() {
864 TaskSnapshot::TaskSnapshot(const BirthOnThread& birth,
865 const DeathData& death_data,
866 const std::string& death_thread_name)
867 : birth(birth),
868 death_data(death_data),
869 death_thread_name(death_thread_name) {
872 TaskSnapshot::~TaskSnapshot() {
875 //------------------------------------------------------------------------------
876 // ParentChildPairSnapshot
878 ParentChildPairSnapshot::ParentChildPairSnapshot() {
881 ParentChildPairSnapshot::ParentChildPairSnapshot(
882 const ThreadData::ParentChildPair& parent_child)
883 : parent(*parent_child.first),
884 child(*parent_child.second) {
887 ParentChildPairSnapshot::~ParentChildPairSnapshot() {
890 //------------------------------------------------------------------------------
891 // ProcessDataSnapshot
893 ProcessDataSnapshot::ProcessDataSnapshot()
894 #if !defined(OS_NACL)
895 : process_id(base::GetCurrentProcId()) {
896 #else
897 : process_id(0) {
898 #endif
901 ProcessDataSnapshot::~ProcessDataSnapshot() {
904 } // namespace tracked_objects