Track thread activities in order to diagnose hangs.

base/synchronization/waitable_event_posix.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
 
+#include "base/debug/activity_tracker.h"
 #include "base/logging.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 
 // -----------------------------------------------------------------------------
 // A WaitableEvent on POSIX is implemented as a wait-list. Currently we don't
 // support cross-process events (where one process can signal an event which
 // others are waiting on). Because of this, we can avoid having one thread per
@@ skipping 130 matching lines @@
   base::Lock lock_;
   base::ConditionVariable cv_;
 };
 
 void WaitableEvent::Wait() {
   bool result = TimedWait(TimeDelta::FromSeconds(-1));
   DCHECK(result) << "TimedWait() should never fail with infinite timeout";
 }
 
 bool WaitableEvent::TimedWait(const TimeDelta& max_time) {
+  // Record the event that this thread is blocking upon (for hang diagnosis).
+  base::debug::ScopedEventWaitActivity event_activity(this);
+
   base::ThreadRestrictions::AssertWaitAllowed();
   const TimeTicks end_time(TimeTicks::Now() + max_time);
   const bool finite_time = max_time.ToInternalValue() >= 0;
 
   kernel_->lock_.Acquire();
   if (kernel_->signaled_) {
     if (!kernel_->manual_reset_) {
       // In this case we were signaled when we had no waiters. Now that
       // someone has waited upon us, we can automatically reset.
       kernel_->signaled_ = false;
@@ skipping 55 matching lines @@
              const std::pair<WaitableEvent*, unsigned> &b) {
   return a.first < b.first;
 }
 
 // static
 size_t WaitableEvent::WaitMany(WaitableEvent** raw_waitables,
                                size_t count) {
   base::ThreadRestrictions::AssertWaitAllowed();
   DCHECK(count) << "Cannot wait on no events";
 
+  // Record an event (the first) that this thread is blocking upon.
+  base::debug::ScopedEventWaitActivity event_activity(raw_waitables[0]);
+
   // We need to acquire the locks in a globally consistent order. Thus we sort
   // the array of waitables by address. We actually sort a pairs so that we can
   // map back to the original index values later.
   std::vector<std::pair<WaitableEvent*, size_t> > waitables;
   waitables.reserve(count);
   for (size_t i = 0; i < count; ++i)
     waitables.push_back(std::make_pair(raw_waitables[i], i));
 
   DCHECK_EQ(count, waitables.size());
 
@@ skipping 161 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 // -----------------------------------------------------------------------------
 
 }  // namespace base