base/tracked_objects.cc

   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.
   4
   5 #include "base/tracked_objects.h"
   6
   7 #include <limits.h>
   8 #include <stdlib.h>
   9
  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"
  21
  22 using base::TimeDelta;
  23
  24 namespace base {
  25 class TimeDelta;
  26 }
  27
  28 namespace tracked_objects {
  29
  30 namespace {
  31 // Flag to compile out almost all of the task tracking code.
  32 const bool kTrackAllTaskObjects = true;
  33
  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;
  38
  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;
  47
  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;
  56
  57 inline bool IsProfilerTimingEnabled() {
  58   enum {
  59     UNDEFINED_TIMING,
  60     ENABLED_TIMING,
  61     DISABLED_TIMING,
  62   };
  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);
  79   }
  80   return current_timing_enabled == ENABLED_TIMING;
  81 }
  82
  83 }  // namespace
  84
  85 //------------------------------------------------------------------------------
  86 // DeathData tallies durations when a death takes place.
  87
  88 DeathData::DeathData() {
  89   Clear();
  90 }
  91
  92 DeathData::DeathData(int count) {
  93   Clear();
  94   count_ = count;
  95 }
  96
  97 // TODO(jar): I need to see if this macro to optimize branching is worth using.
  98 //
  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))
 106
 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;
 115
 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;
 120
 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;
 131   }
 132 }
 133
 134 int DeathData::count() const { return count_; }
 135
 136 int32 DeathData::run_duration_sum() const { return run_duration_sum_; }
 137
 138 int32 DeathData::run_duration_max() const { return run_duration_max_; }
 139
 140 int32 DeathData::run_duration_sample() const {
 141   return run_duration_sample_;
 142 }
 143
 144 int32 DeathData::queue_duration_sum() const {
 145   return queue_duration_sum_;
 146 }
 147
 148 int32 DeathData::queue_duration_max() const {
 149   return queue_duration_max_;
 150 }
 151
 152 int32 DeathData::queue_duration_sample() const {
 153   return queue_duration_sample_;
 154 }
 155
 156 void DeathData::ResetMax() {
 157   run_duration_max_ = 0;
 158   queue_duration_max_ = 0;
 159 }
 160
 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;
 169 }
 170
 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) {
 180 }
 181
 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()) {
 191 }
 192
 193 DeathDataSnapshot::~DeathDataSnapshot() {
 194 }
 195
 196 //------------------------------------------------------------------------------
 197 BirthOnThread::BirthOnThread(const Location& location,
 198                              const ThreadData& current)
 199     : location_(location),
 200       birth_thread_(&current) {
 201 }
 202
 203 //------------------------------------------------------------------------------
 204 BirthOnThreadSnapshot::BirthOnThreadSnapshot() {
 205 }
 206
 207 BirthOnThreadSnapshot::BirthOnThreadSnapshot(
 208     const tracked_objects::BirthOnThread& birth)
 209     : location(birth.location()),
 210       thread_name(birth.birth_thread()->thread_name()) {
 211 }
 212
 213 BirthOnThreadSnapshot::~BirthOnThreadSnapshot() {
 214 }
 215
 216 //------------------------------------------------------------------------------
 217 Births::Births(const Location& location, const ThreadData& current)
 218     : BirthOnThread(location, current),
 219       birth_count_(1) { }
 220
 221 int Births::birth_count() const { return birth_count_; }
 222
 223 void Births::RecordBirth() { ++birth_count_; }
 224
 225 void Births::ForgetBirth() { --birth_count_; }
 226
 227 void Births::Clear() { birth_count_ = 0; }
 228
 229 //------------------------------------------------------------------------------
 230 // ThreadData maintains the central data for all births and deaths on a single
 231 // thread.
 232
 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.
 236
 237 // static
 238 NowFunction* ThreadData::now_function_ = NULL;
 239
 240 // static
 241 bool ThreadData::now_function_is_time_ = false;
 242
 243 // A TLS slot which points to the ThreadData instance for the current thread. We
 244 // do a fake initialization here (zeroing out data), and then the real in-place
 245 // construction happens when we call tls_index_.Initialize().
 246 // static
 247 base::ThreadLocalStorage::StaticSlot ThreadData::tls_index_ = TLS_INITIALIZER;
 248
 249 // static
 250 int ThreadData::worker_thread_data_creation_count_ = 0;
 251
 252 // static
 253 int ThreadData::cleanup_count_ = 0;
 254
 255 // static
 256 int ThreadData::incarnation_counter_ = 0;
 257
 258 // static
 259 ThreadData* ThreadData::all_thread_data_list_head_ = NULL;
 260
 261 // static
 262 ThreadData* ThreadData::first_retired_worker_ = NULL;
 263
 264 // static
 265 base::LazyInstance<base::Lock>::Leaky
 266     ThreadData::list_lock_ = LAZY_INSTANCE_INITIALIZER;
 267
 268 // static
 269 ThreadData::Status ThreadData::status_ = ThreadData::UNINITIALIZED;
 270
 271 ThreadData::ThreadData(const std::string& suggested_name)
 272     : next_(NULL),
 273       next_retired_worker_(NULL),
 274       worker_thread_number_(0),
 275       incarnation_count_for_pool_(-1),
 276       current_stopwatch_(NULL) {
 277   DCHECK_GE(suggested_name.size(), 0u);
 278   thread_name_ = suggested_name;
 279   PushToHeadOfList();  // Which sets real incarnation_count_for_pool_.
 280 }
 281
 282 ThreadData::ThreadData(int thread_number)
 283     : next_(NULL),
 284       next_retired_worker_(NULL),
 285       worker_thread_number_(thread_number),
 286       incarnation_count_for_pool_(-1),
 287       current_stopwatch_(NULL) {
 288   CHECK_GT(thread_number, 0);
 289   base::StringAppendF(&thread_name_, "WorkerThread-%d", thread_number);
 290   PushToHeadOfList();  // Which sets real incarnation_count_for_pool_.
 291 }
 292
 293 ThreadData::~ThreadData() {}
 294
 295 void ThreadData::PushToHeadOfList() {
 296   // Toss in a hint of randomness (atop the uniniitalized value).
 297   (void)VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE(&random_number_,
 298                                                  sizeof(random_number_));
 299   MSAN_UNPOISON(&random_number_, sizeof(random_number_));
 300   random_number_ += static_cast<int32>(this - static_cast<ThreadData*>(0));
 301   random_number_ ^= (Now() - TrackedTime()).InMilliseconds();
 302
 303   DCHECK(!next_);
 304   base::AutoLock lock(*list_lock_.Pointer());
 305   incarnation_count_for_pool_ = incarnation_counter_;
 306   next_ = all_thread_data_list_head_;
 307   all_thread_data_list_head_ = this;
 308 }
 309
 310 // static
 311 ThreadData* ThreadData::first() {
 312   base::AutoLock lock(*list_lock_.Pointer());
 313   return all_thread_data_list_head_;
 314 }
 315
 316 ThreadData* ThreadData::next() const { return next_; }
 317
 318 // static
 319 void ThreadData::InitializeThreadContext(const std::string& suggested_name) {
 320   if (!Initialize())  // Always initialize if needed.
 321     return;
 322   ThreadData* current_thread_data =
 323       reinterpret_cast<ThreadData*>(tls_index_.Get());
 324   if (current_thread_data)
 325     return;  // Browser tests instigate this.
 326   current_thread_data = new ThreadData(suggested_name);
 327   tls_index_.Set(current_thread_data);
 328 }
 329
 330 // static
 331 ThreadData* ThreadData::Get() {
 332   if (!tls_index_.initialized())
 333     return NULL;  // For unittests only.
 334   ThreadData* registered = reinterpret_cast<ThreadData*>(tls_index_.Get());
 335   if (registered)
 336     return registered;
 337
 338   // We must be a worker thread, since we didn't pre-register.
 339   ThreadData* worker_thread_data = NULL;
 340   int worker_thread_number = 0;
 341   {
 342     base::AutoLock lock(*list_lock_.Pointer());
 343     if (first_retired_worker_) {
 344       worker_thread_data = first_retired_worker_;
 345       first_retired_worker_ = first_retired_worker_->next_retired_worker_;
 346       worker_thread_data->next_retired_worker_ = NULL;
 347     } else {
 348       worker_thread_number = ++worker_thread_data_creation_count_;
 349     }
 350   }
 351
 352   // If we can't find a previously used instance, then we have to create one.
 353   if (!worker_thread_data) {
 354     DCHECK_GT(worker_thread_number, 0);
 355     worker_thread_data = new ThreadData(worker_thread_number);
 356   }
 357   DCHECK_GT(worker_thread_data->worker_thread_number_, 0);
 358
 359   tls_index_.Set(worker_thread_data);
 360   return worker_thread_data;
 361 }
 362
 363 // static
 364 void ThreadData::OnThreadTermination(void* thread_data) {
 365   DCHECK(thread_data);  // TLS should *never* call us with a NULL.
 366   // We must NOT do any allocations during this callback. There is a chance
 367   // that the allocator is no longer active on this thread.
 368   if (!kTrackAllTaskObjects)
 369     return;  // Not compiled in.
 370   reinterpret_cast<ThreadData*>(thread_data)->OnThreadTerminationCleanup();
 371 }
 372
 373 void ThreadData::OnThreadTerminationCleanup() {
 374   // The list_lock_ was created when we registered the callback, so it won't be
 375   // allocated here despite the lazy reference.
 376   base::AutoLock lock(*list_lock_.Pointer());
 377   if (incarnation_counter_ != incarnation_count_for_pool_)
 378     return;  // ThreadData was constructed in an earlier unit test.
 379   ++cleanup_count_;
 380   // Only worker threads need to be retired and reused.
 381   if (!worker_thread_number_) {
 382     return;
 383   }
 384   // We must NOT do any allocations during this callback.
 385   // Using the simple linked lists avoids all allocations.
 386   DCHECK_EQ(this->next_retired_worker_, reinterpret_cast<ThreadData*>(NULL));
 387   this->next_retired_worker_ = first_retired_worker_;
 388   first_retired_worker_ = this;
 389 }
 390
 391 // static
 392 void ThreadData::Snapshot(bool reset_max, ProcessDataSnapshot* process_data) {
 393   // Add births that have run to completion to |collected_data|.
 394   // |birth_counts| tracks the total number of births recorded at each location
 395   // for which we have not seen a death count.
 396   BirthCountMap birth_counts;
 397   ThreadData::SnapshotAllExecutedTasks(reset_max, process_data, &birth_counts);
 398
 399   // Add births that are still active -- i.e. objects that have tallied a birth,
 400   // but have not yet tallied a matching death, and hence must be either
 401   // running, queued up, or being held in limbo for future posting.
 402   for (BirthCountMap::const_iterator it = birth_counts.begin();
 403        it != birth_counts.end(); ++it) {
 404     if (it->second > 0) {
 405       process_data->tasks.push_back(
 406           TaskSnapshot(*it->first, DeathData(it->second), "Still_Alive"));
 407     }
 408   }
 409 }
 410
 411 Births* ThreadData::TallyABirth(const Location& location) {
 412   BirthMap::iterator it = birth_map_.find(location);
 413   Births* child;
 414   if (it != birth_map_.end()) {
 415     child =  it->second;
 416     child->RecordBirth();
 417   } else {
 418     child = new Births(location, *this);  // Leak this.
 419     // Lock since the map may get relocated now, and other threads sometimes
 420     // snapshot it (but they lock before copying it).
 421     base::AutoLock lock(map_lock_);
 422     birth_map_[location] = child;
 423   }
 424
 425   if (kTrackParentChildLinks && status_ > PROFILING_ACTIVE &&
 426       !parent_stack_.empty()) {
 427     const Births* parent = parent_stack_.top();
 428     ParentChildPair pair(parent, child);
 429     if (parent_child_set_.find(pair) == parent_child_set_.end()) {
 430       // Lock since the map may get relocated now, and other threads sometimes
 431       // snapshot it (but they lock before copying it).
 432       base::AutoLock lock(map_lock_);
 433       parent_child_set_.insert(pair);
 434     }
 435   }
 436
 437   return child;
 438 }
 439
 440 void ThreadData::TallyADeath(const Births& birth,
 441                              int32 queue_duration,
 442                              const TaskStopwatch& stopwatch) {
 443   int32 run_duration = stopwatch.RunDurationMs();
 444
 445   // Stir in some randomness, plus add constant in case durations are zero.
 446   const int32 kSomePrimeNumber = 2147483647;
 447   random_number_ += queue_duration + run_duration + kSomePrimeNumber;
 448   // An address is going to have some randomness to it as well ;-).
 449   random_number_ ^= static_cast<int32>(&birth - reinterpret_cast<Births*>(0));
 450
 451   // We don't have queue durations without OS timer. OS timer is automatically
 452   // used for task-post-timing, so the use of an alternate timer implies all
 453   // queue times are invalid, unless it was explicitly said that we can trust
 454   // the alternate timer.
 455   if (kAllowAlternateTimeSourceHandling &&
 456       now_function_ &&
 457       !now_function_is_time_) {
 458     queue_duration = 0;
 459   }
 460
 461   DeathMap::iterator it = death_map_.find(&birth);
 462   DeathData* death_data;
 463   if (it != death_map_.end()) {
 464     death_data = &it->second;
 465   } else {
 466     base::AutoLock lock(map_lock_);  // Lock as the map may get relocated now.
 467     death_data = &death_map_[&birth];
 468   }  // Release lock ASAP.
 469   death_data->RecordDeath(queue_duration, run_duration, random_number_);
 470
 471   if (!kTrackParentChildLinks)
 472     return;
 473   if (!parent_stack_.empty()) {  // We might get turned off.
 474     DCHECK_EQ(parent_stack_.top(), &birth);
 475     parent_stack_.pop();
 476   }
 477 }
 478
 479 // static
 480 Births* ThreadData::TallyABirthIfActive(const Location& location) {
 481   if (!kTrackAllTaskObjects)
 482     return NULL;  // Not compiled in.
 483
 484   if (!TrackingStatus())
 485     return NULL;
 486   ThreadData* current_thread_data = Get();
 487   if (!current_thread_data)
 488     return NULL;
 489   return current_thread_data->TallyABirth(location);
 490 }
 491
 492 // static
 493 void ThreadData::TallyRunOnNamedThreadIfTracking(
 494     const base::TrackingInfo& completed_task,
 495     const TaskStopwatch& stopwatch) {
 496   if (!kTrackAllTaskObjects)
 497     return;  // Not compiled in.
 498
 499   // Even if we have been DEACTIVATED, we will process any pending births so
 500   // that our data structures (which counted the outstanding births) remain
 501   // consistent.
 502   const Births* birth = completed_task.birth_tally;
 503   if (!birth)
 504     return;
 505   ThreadData* current_thread_data = stopwatch.GetThreadData();
 506   if (!current_thread_data)
 507     return;
 508
 509   // Watch out for a race where status_ is changing, and hence one or both
 510   // of start_of_run or end_of_run is zero.  In that case, we didn't bother to
 511   // get a time value since we "weren't tracking" and we were trying to be
 512   // efficient by not calling for a genuine time value. For simplicity, we'll
 513   // use a default zero duration when we can't calculate a true value.
 514   TrackedTime start_of_run = stopwatch.StartTime();
 515   int32 queue_duration = 0;
 516   if (!start_of_run.is_null()) {
 517     queue_duration = (start_of_run - completed_task.EffectiveTimePosted())
 518         .InMilliseconds();
 519   }
 520   current_thread_data->TallyADeath(*birth, queue_duration, stopwatch);
 521 }
 522
 523 // static
 524 void ThreadData::TallyRunOnWorkerThreadIfTracking(
 525     const Births* birth,
 526     const TrackedTime& time_posted,
 527     const TaskStopwatch& stopwatch) {
 528   if (!kTrackAllTaskObjects)
 529     return;  // Not compiled in.
 530
 531   // Even if we have been DEACTIVATED, we will process any pending births so
 532   // that our data structures (which counted the outstanding births) remain
 533   // consistent.
 534   if (!birth)
 535     return;
 536
 537   // TODO(jar): Support the option to coalesce all worker-thread activity under
 538   // one ThreadData instance that uses locks to protect *all* access.  This will
 539   // reduce memory (making it provably bounded), but run incrementally slower
 540   // (since we'll use locks on TallyABirth and TallyADeath).  The good news is
 541   // that the locks on TallyADeath will be *after* the worker thread has run,
 542   // and hence nothing will be waiting for the completion (... besides some
 543   // other thread that might like to run).  Also, the worker threads tasks are
 544   // generally longer, and hence the cost of the lock may perchance be amortized
 545   // over the long task's lifetime.
 546   ThreadData* current_thread_data = stopwatch.GetThreadData();
 547   if (!current_thread_data)
 548     return;
 549
 550   TrackedTime start_of_run = stopwatch.StartTime();
 551   int32 queue_duration = 0;
 552   if (!start_of_run.is_null()) {
 553     queue_duration = (start_of_run - time_posted).InMilliseconds();
 554   }
 555   current_thread_data->TallyADeath(*birth, queue_duration, stopwatch);
 556 }
 557
 558 // static
 559 void ThreadData::TallyRunInAScopedRegionIfTracking(
 560     const Births* birth,
 561     const TaskStopwatch& stopwatch) {
 562   if (!kTrackAllTaskObjects)
 563     return;  // Not compiled in.
 564
 565   // Even if we have been DEACTIVATED, we will process any pending births so
 566   // that our data structures (which counted the outstanding births) remain
 567   // consistent.
 568   if (!birth)
 569     return;
 570
 571   ThreadData* current_thread_data = stopwatch.GetThreadData();
 572   if (!current_thread_data)
 573     return;
 574
 575   int32 queue_duration = 0;
 576   current_thread_data->TallyADeath(*birth, queue_duration, stopwatch);
 577 }
 578
 579 // static
 580 void ThreadData::SnapshotAllExecutedTasks(bool reset_max,
 581                                           ProcessDataSnapshot* process_data,
 582                                           BirthCountMap* birth_counts) {
 583   if (!kTrackAllTaskObjects)
 584     return;  // Not compiled in.
 585
 586   // Get an unchanging copy of a ThreadData list.
 587   ThreadData* my_list = ThreadData::first();
 588
 589   // Gather data serially.
 590   // This hackish approach *can* get some slighly corrupt tallies, as we are
 591   // grabbing values without the protection of a lock, but it has the advantage
 592   // of working even with threads that don't have message loops.  If a user
 593   // sees any strangeness, they can always just run their stats gathering a
 594   // second time.
 595   for (ThreadData* thread_data = my_list;
 596        thread_data;
 597        thread_data = thread_data->next()) {
 598     thread_data->SnapshotExecutedTasks(reset_max, process_data, birth_counts);
 599   }
 600 }
 601
 602 void ThreadData::SnapshotExecutedTasks(bool reset_max,
 603                                        ProcessDataSnapshot* process_data,
 604                                        BirthCountMap* birth_counts) {
 605   // Get copy of data, so that the data will not change during the iterations
 606   // and processing.
 607   ThreadData::BirthMap birth_map;
 608   ThreadData::DeathMap death_map;
 609   ThreadData::ParentChildSet parent_child_set;
 610   SnapshotMaps(reset_max, &birth_map, &death_map, &parent_child_set);
 611
 612   for (ThreadData::DeathMap::const_iterator it = death_map.begin();
 613        it != death_map.end(); ++it) {
 614     process_data->tasks.push_back(
 615         TaskSnapshot(*it->first, it->second, thread_name()));
 616     (*birth_counts)[it->first] -= it->first->birth_count();
 617   }
 618
 619   for (ThreadData::BirthMap::const_iterator it = birth_map.begin();
 620        it != birth_map.end(); ++it) {
 621     (*birth_counts)[it->second] += it->second->birth_count();
 622   }
 623
 624   if (!kTrackParentChildLinks)
 625     return;
 626
 627   for (ThreadData::ParentChildSet::const_iterator it = parent_child_set.begin();
 628        it != parent_child_set.end(); ++it) {
 629     process_data->descendants.push_back(ParentChildPairSnapshot(*it));
 630   }
 631 }
 632
 633 // This may be called from another thread.
 634 void ThreadData::SnapshotMaps(bool reset_max,
 635                               BirthMap* birth_map,
 636                               DeathMap* death_map,
 637                               ParentChildSet* parent_child_set) {
 638   base::AutoLock lock(map_lock_);
 639   for (BirthMap::const_iterator it = birth_map_.begin();
 640        it != birth_map_.end(); ++it)
 641     (*birth_map)[it->first] = it->second;
 642   for (DeathMap::iterator it = death_map_.begin();
 643        it != death_map_.end(); ++it) {
 644     (*death_map)[it->first] = it->second;
 645     if (reset_max)
 646       it->second.ResetMax();
 647   }
 648
 649   if (!kTrackParentChildLinks)
 650     return;
 651
 652   for (ParentChildSet::iterator it = parent_child_set_.begin();
 653        it != parent_child_set_.end(); ++it)
 654     parent_child_set->insert(*it);
 655 }
 656
 657 // static
 658 void ThreadData::ResetAllThreadData() {
 659   ThreadData* my_list = first();
 660
 661   for (ThreadData* thread_data = my_list;
 662        thread_data;
 663        thread_data = thread_data->next())
 664     thread_data->Reset();
 665 }
 666
 667 void ThreadData::Reset() {
 668   base::AutoLock lock(map_lock_);
 669   for (DeathMap::iterator it = death_map_.begin();
 670        it != death_map_.end(); ++it)
 671     it->second.Clear();
 672   for (BirthMap::iterator it = birth_map_.begin();
 673        it != birth_map_.end(); ++it)
 674     it->second->Clear();
 675 }
 676
 677 static void OptionallyInitializeAlternateTimer() {
 678   NowFunction* alternate_time_source = GetAlternateTimeSource();
 679   if (alternate_time_source)
 680     ThreadData::SetAlternateTimeSource(alternate_time_source);
 681 }
 682
 683 bool ThreadData::Initialize() {
 684   if (!kTrackAllTaskObjects)
 685     return false;  // Not compiled in.
 686   if (status_ >= DEACTIVATED)
 687     return true;  // Someone else did the initialization.
 688   // Due to racy lazy initialization in tests, we'll need to recheck status_
 689   // after we acquire the lock.
 690
 691   // Ensure that we don't double initialize tls.  We are called when single
 692   // threaded in the product, but some tests may be racy and lazy about our
 693   // initialization.
 694   base::AutoLock lock(*list_lock_.Pointer());
 695   if (status_ >= DEACTIVATED)
 696     return true;  // Someone raced in here and beat us.
 697
 698   // Put an alternate timer in place if the environment calls for it, such as
 699   // for tracking TCMalloc allocations.  This insertion is idempotent, so we
 700   // don't mind if there is a race, and we'd prefer not to be in a lock while
 701   // doing this work.
 702   if (kAllowAlternateTimeSourceHandling)
 703     OptionallyInitializeAlternateTimer();
 704
 705   // Perform the "real" TLS initialization now, and leave it intact through
 706   // process termination.
 707   if (!tls_index_.initialized()) {  // Testing may have initialized this.
 708     DCHECK_EQ(status_, UNINITIALIZED);
 709     tls_index_.Initialize(&ThreadData::OnThreadTermination);
 710     if (!tls_index_.initialized())
 711       return false;
 712   } else {
 713     // TLS was initialzed for us earlier.
 714     DCHECK_EQ(status_, DORMANT_DURING_TESTS);
 715   }
 716
 717   // Incarnation counter is only significant to testing, as it otherwise will
 718   // never again change in this process.
 719   ++incarnation_counter_;
 720
 721   // The lock is not critical for setting status_, but it doesn't hurt. It also
 722   // ensures that if we have a racy initialization, that we'll bail as soon as
 723   // we get the lock earlier in this method.
 724   status_ = kInitialStartupState;
 725   if (!kTrackParentChildLinks &&
 726       kInitialStartupState == PROFILING_CHILDREN_ACTIVE)
 727     status_ = PROFILING_ACTIVE;
 728   DCHECK(status_ != UNINITIALIZED);
 729   return true;
 730 }
 731
 732 // static
 733 bool ThreadData::InitializeAndSetTrackingStatus(Status status) {
 734   DCHECK_GE(status, DEACTIVATED);
 735   DCHECK_LE(status, PROFILING_CHILDREN_ACTIVE);
 736
 737   if (!Initialize())  // No-op if already initialized.
 738     return false;  // Not compiled in.
 739
 740   if (!kTrackParentChildLinks && status > DEACTIVATED)
 741     status = PROFILING_ACTIVE;
 742   status_ = status;
 743   return true;
 744 }
 745
 746 // static
 747 ThreadData::Status ThreadData::status() {
 748   return status_;
 749 }
 750
 751 // static
 752 bool ThreadData::TrackingStatus() {
 753   return status_ > DEACTIVATED;
 754 }
 755
 756 // static
 757 bool ThreadData::TrackingParentChildStatus() {
 758   return status_ >= PROFILING_CHILDREN_ACTIVE;
 759 }
 760
 761 // static
 762 void ThreadData::PrepareForStartOfRun(const Births* parent) {
 763   if (kTrackParentChildLinks && parent && status_ > PROFILING_ACTIVE) {
 764     ThreadData* current_thread_data = Get();
 765     if (current_thread_data)
 766       current_thread_data->parent_stack_.push(parent);
 767   }
 768 }
 769
 770 // static
 771 void ThreadData::SetAlternateTimeSource(NowFunction* now_function) {
 772   DCHECK(now_function);
 773   if (kAllowAlternateTimeSourceHandling)
 774     now_function_ = now_function;
 775 }
 776
 777 // static
 778 TrackedTime ThreadData::Now() {
 779   if (kAllowAlternateTimeSourceHandling && now_function_)
 780     return TrackedTime::FromMilliseconds((*now_function_)());
 781   if (kTrackAllTaskObjects && IsProfilerTimingEnabled() && TrackingStatus())
 782     return TrackedTime::Now();
 783   return TrackedTime();  // Super fast when disabled, or not compiled.
 784 }
 785
 786 // static
 787 void ThreadData::EnsureCleanupWasCalled(int major_threads_shutdown_count) {
 788   base::AutoLock lock(*list_lock_.Pointer());
 789   if (worker_thread_data_creation_count_ == 0)
 790     return;  // We haven't really run much, and couldn't have leaked.
 791
 792   // TODO(jar): until this is working on XP, don't run the real test.
 793 #if 0
 794   // Verify that we've at least shutdown/cleanup the major namesd threads.  The
 795   // caller should tell us how many thread shutdowns should have taken place by
 796   // now.
 797   CHECK_GT(cleanup_count_, major_threads_shutdown_count);
 798 #endif
 799 }
 800
 801 // static
 802 void ThreadData::ShutdownSingleThreadedCleanup(bool leak) {
 803   // This is only called from test code, where we need to cleanup so that
 804   // additional tests can be run.
 805   // We must be single threaded... but be careful anyway.
 806   if (!InitializeAndSetTrackingStatus(DEACTIVATED))
 807     return;
 808   ThreadData* thread_data_list;
 809   {
 810     base::AutoLock lock(*list_lock_.Pointer());
 811     thread_data_list = all_thread_data_list_head_;
 812     all_thread_data_list_head_ = NULL;
 813     ++incarnation_counter_;
 814     // To be clean, break apart the retired worker list (though we leak them).
 815     while (first_retired_worker_) {
 816       ThreadData* worker = first_retired_worker_;
 817       CHECK_GT(worker->worker_thread_number_, 0);
 818       first_retired_worker_ = worker->next_retired_worker_;
 819       worker->next_retired_worker_ = NULL;
 820     }
 821   }
 822
 823   // Put most global static back in pristine shape.
 824   worker_thread_data_creation_count_ = 0;
 825   cleanup_count_ = 0;
 826   tls_index_.Set(NULL);
 827   status_ = DORMANT_DURING_TESTS;  // Almost UNINITIALIZED.
 828
 829   // To avoid any chance of racing in unit tests, which is the only place we
 830   // call this function, we may sometimes leak all the data structures we
 831   // recovered, as they may still be in use on threads from prior tests!
 832   if (leak) {
 833     ThreadData* thread_data = thread_data_list;
 834     while (thread_data) {
 835       ANNOTATE_LEAKING_OBJECT_PTR(thread_data);
 836       thread_data = thread_data->next();
 837     }
 838     return;
 839   }
 840
 841   // When we want to cleanup (on a single thread), here is what we do.
 842
 843   // Do actual recursive delete in all ThreadData instances.
 844   while (thread_data_list) {
 845     ThreadData* next_thread_data = thread_data_list;
 846     thread_data_list = thread_data_list->next();
 847
 848     for (BirthMap::iterator it = next_thread_data->birth_map_.begin();
 849          next_thread_data->birth_map_.end() != it; ++it)
 850       delete it->second;  // Delete the Birth Records.
 851     delete next_thread_data;  // Includes all Death Records.
 852   }
 853 }
 854
 855 //------------------------------------------------------------------------------
 856 TaskStopwatch::TaskStopwatch()
 857     : start_time_(ThreadData::Now()),
 858       current_thread_data_(ThreadData::Get()),
 859       excluded_duration_ms_(0),
 860       parent_(NULL) {
 861 #if DCHECK_IS_ON
 862   state_ = RUNNING;
 863   child_ = NULL;
 864 #endif
 865
 866   wallclock_duration_ms_ = 0;
 867   if (!current_thread_data_)
 868     return;
 869
 870   parent_ = current_thread_data_->current_stopwatch_;
 871 #if DCHECK_IS_ON
 872   if (parent_) {
 873     DCHECK(parent_->state_ == RUNNING);
 874     DCHECK(parent_->child_ == NULL);
 875     parent_->child_ = this;
 876   }
 877 #endif
 878   current_thread_data_->current_stopwatch_ = this;
 879 }
 880
 881 TaskStopwatch::~TaskStopwatch() {
 882 #if DCHECK_IS_ON
 883   DCHECK(state_ != RUNNING);
 884   DCHECK(child_ == NULL);
 885 #endif
 886 }
 887
 888 void TaskStopwatch::Stop() {
 889   const TrackedTime end_time = ThreadData::Now();
 890 #if DCHECK_IS_ON
 891   DCHECK(state_ == RUNNING);
 892   state_ = STOPPED;
 893   DCHECK(child_ == NULL);
 894 #endif
 895
 896   if (!start_time_.is_null() && !end_time.is_null()) {
 897     wallclock_duration_ms_ = (end_time - start_time_).InMilliseconds();
 898   }
 899
 900   if (!current_thread_data_)
 901     return;
 902
 903   DCHECK(current_thread_data_->current_stopwatch_ == this);
 904   current_thread_data_->current_stopwatch_ = parent_;
 905   if (!parent_)
 906     return;
 907
 908 #if DCHECK_IS_ON
 909   DCHECK(parent_->state_ == RUNNING);
 910   DCHECK(parent_->child_ == this);
 911   parent_->child_ = NULL;
 912 #endif
 913   parent_->excluded_duration_ms_ +=
 914       wallclock_duration_ms_;
 915   parent_ = NULL;
 916 }
 917
 918 TrackedTime TaskStopwatch::StartTime() const {
 919   return start_time_;
 920 }
 921
 922 int32 TaskStopwatch::RunDurationMs() const {
 923 #if DCHECK_IS_ON
 924   DCHECK(state_ == STOPPED);
 925 #endif
 926
 927   return wallclock_duration_ms_ - excluded_duration_ms_;
 928 }
 929
 930 ThreadData* TaskStopwatch::GetThreadData() const {
 931   return current_thread_data_;
 932 }
 933
 934 //------------------------------------------------------------------------------
 935 TaskSnapshot::TaskSnapshot() {
 936 }
 937
 938 TaskSnapshot::TaskSnapshot(const BirthOnThread& birth,
 939                            const DeathData& death_data,
 940                            const std::string& death_thread_name)
 941     : birth(birth),
 942       death_data(death_data),
 943       death_thread_name(death_thread_name) {
 944 }
 945
 946 TaskSnapshot::~TaskSnapshot() {
 947 }
 948
 949 //------------------------------------------------------------------------------
 950 // ParentChildPairSnapshot
 951
 952 ParentChildPairSnapshot::ParentChildPairSnapshot() {
 953 }
 954
 955 ParentChildPairSnapshot::ParentChildPairSnapshot(
 956     const ThreadData::ParentChildPair& parent_child)
 957     : parent(*parent_child.first),
 958       child(*parent_child.second) {
 959 }
 960
 961 ParentChildPairSnapshot::~ParentChildPairSnapshot() {
 962 }
 963
 964 //------------------------------------------------------------------------------
 965 // ProcessDataSnapshot
 966
 967 ProcessDataSnapshot::ProcessDataSnapshot()
 968 #if !defined(OS_NACL)
 969     : process_id(base::GetCurrentProcId()) {
 970 #else
 971     : process_id(0) {
 972 #endif
 973 }
 974
 975 ProcessDataSnapshot::~ProcessDataSnapshot() {
 976 }
 977
 978 }  // namespace tracked_objects