Track thread activities in order to diagnose hangs.

base/debug/activity_tracker.cc

+// Copyright 2016 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 "base/debug/activity_tracker.h"
+
+#include <atomic>
+
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "base/files/memory_mapped_file.h"
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial.h"
+#include "base/pending_task.h"
+#include "base/stl_util.h"
+#include "base/strings/string_util.h"
+
+namespace base {
+namespace debug {
+
+namespace {
+
+// A number that identifies the memory as having been initialized. It's
+// arbitrary but happens to be the first 8 bytes of SHA1(ThreadActivityTracker).
+// A version number is added on so that major structure changes won't try to
+// read an older version (since the cookie won't match).
+const uint64_t kHeaderCookie = 0xC0029B240D4A3092ULL + 1;  // v1
+
+// The minimum depth a stack should support.
+const int kMinStackDepth = 2;
+
+}  // namespace
+
+
+#if !defined(OS_NACL)  // NACL doesn't support any kind of file access in build.
+void SetupGlobalActivityTrackerFieldTrial(const FilePath& file) {
+  const Feature kActivityTrackerFeature{
+      "ActivityTracking", FEATURE_DISABLED_BY_DEFAULT
+  };
+
+  if (!base::FeatureList::IsEnabled(kActivityTrackerFeature))
+    return;
+
+  // TODO(bcwhite): Adjust these numbers once there is real data to show
+  // just how much of an arena is necessary.
+  const size_t kMemorySize = 1 << 20;  // 1 MiB
+  const int kStackDepth = 3;
+  const uint64_t kAllocatorId = 0;
+  const char kAllocatorName[] = "ActivityTracker";
+
+  GlobalActivityTracker::CreateWithFile(
+      file.AddExtension(PersistentMemoryAllocator::kFileExtension),
+      kMemorySize, kAllocatorId, kAllocatorName, kStackDepth);
+}
+#endif  // !defined(OS_NACL)
+
+// This information is kept for every thread that is tracked. It is filled
+// the very first time the thread is seen. All fields must be of exact sizes
+// so there is no issue moving between 32 and 64-bit builds.
+struct ThreadActivityTracker::Header {
+  // This unique number indicates a valid initialization of the memory.
+  uint64_t cookie;
+
+  // The thread-id to which this data belongs. This identifier is not
+  // guaranteed to mean anything, just to be unique among all active
+  // trackers.
+  uint64_t thread_id;
+
+  // The start-time and start-ticks when the data was created. Each activity
+  // record has a |time_ticks| value that can be converted to a "wall time"
+  // with these two values.
+  int64_t start_time;
+  int64_t start_ticks;
+
+  // The number of Activity slots in the data.
+  uint32_t slots;
+
+  // The current depth of the stack. This may be greater than the number of
+  // slots. If the depth exceeds the number of slots, the newest entries
+  // won't be recorded.
+  std::atomic<uint32_t> depth;
+
+  // A memory location used to indicate if changes have been made to the stack
+  // that would invalidate an in-progress read of its contents. The active
+  // tracker will zero the value whenever something gets popped from the
+  // stack. A monitoring tracker can write a non-zero value here, copy the
+  // stack contents, and read the value to know, if it is still non-zero, that
+  // the contents didn't change while being copied.
+  std::atomic<uint32_t> unchanged;
+
+  // The name of the thread (up to a maximum length). Dynamic-length names
+  // are not practical since the memory has to come from the same persistent
+  // allocator that holds this structure and to which this object has no
+  // reference.
+  char name[32];
+};
+
+ThreadActivityTracker::ThreadActivityTracker(void* base, size_t size)
+    : header_(static_cast<Header*>(base)),
+      stack_(reinterpret_cast<StackEntry*>(reinterpret_cast<char*>(base) +
+                                           sizeof(Header))),
+      stack_slots_((size - sizeof(Header)) / sizeof(StackEntry)) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(base);
+
+  // Ensure there is enough space for the header and at least a few records.
+  DCHECK_LE(sizeof(Header) + kMinStackDepth * sizeof(StackEntry), size);
+
+  // Ensure that the |stack_slots_| calculation didn't overflow.
+  DCHECK_GE(std::numeric_limits<uint32_t>::max(),
+            (size - sizeof(Header)) / sizeof(StackEntry));
+
+  // Provided memory should either be completely initialized or all zeros.
+  if (header_->cookie == 0) {
+    // This is a new file. Double-check other fields and then initialize.
+    DCHECK_EQ(0U, header_->thread_id);
+    DCHECK_EQ(0, header_->start_time);
+    DCHECK_EQ(0, header_->start_ticks);
+    DCHECK_EQ(0U, header_->slots);
+    DCHECK_EQ(0U, header_->depth.load(std::memory_order_relaxed));
+    DCHECK_EQ(0U, header_->unchanged.load(std::memory_order_relaxed));
+    DCHECK_EQ(0, stack_[0].time_ticks);
+    DCHECK_EQ(0U, stack_[0].source_address);
+    DCHECK_EQ(0U, stack_[0].data.task.sequence_id);
+
+    header_->cookie = kHeaderCookie;
+    header_->thread_id = static_cast<uint64_t>(PlatformThread::CurrentId());
+    header_->start_time = base::Time::Now().ToInternalValue();
+    header_->start_ticks = base::TimeTicks::Now().ToInternalValue();
+    header_->slots = stack_slots_;
+    strlcpy(header_->name, PlatformThread::GetName(), sizeof(header_->name));
+    valid_ = true;
+  } else {
+    // This is a file with existing data. Perform basic consistency checks.
+    if (header_->cookie != kHeaderCookie ||
+        header_->slots != stack_slots_ ||
+        header_->start_time > base::Time::Now().ToInternalValue())
+      return;
+    valid_ = true;
+  }
+}
+
+ThreadActivityTracker::~ThreadActivityTracker() {}
+
+void ThreadActivityTracker::PushActivity(const void* source,
+                                         ActivityType activity,
+                                         const StackEntryData& data) {
+  // A thread-checker creates a lock to check the thread-id which means
+  // re-entry into this code when locks are being tracked.
+  DCHECK(activity == ACT_LOCK || thread_checker_.CalledOnValidThread());
+
+  // Get the current depth of the stack. No access to other memory guarded
+  // by this variable is done here so a "relaxed" load is acceptable.
+  uint32_t depth = header_->depth.load(std::memory_order_relaxed);
+
+  // Handle the case where the stack depth has exceeded the storage capacity.
+  // Extra entries will be lost leaving only the base of the stack.
+  if (depth >= stack_slots_) {
+    // Since no other memory is being modified, a "relaxed" store is acceptable.
+    header_->depth.store(depth + 1, std::memory_order_relaxed);
+    return;
+  }
+
+  // Get a pointer to the next entry and load it. No atomicity is required
+  // here because the memory is known only to this thread. It will be made
+  // known to other threads once the depth is incremented.
+  StackEntry* entry = &stack_[depth];
+  entry->time_ticks = base::TimeTicks::Now().ToInternalValue();
+  entry->source_address = reinterpret_cast<uintptr_t>(source);
+  entry->activity_type = activity;
+  entry->data = data;
+
+  // Save the incremented depth. Because this guards |entry| memory filled
+  // above that may be read by another thread once the recorded depth changes,
+  // a "release" store is required.
+  header_->depth.store(depth + 1, std::memory_order_release);
+}
+
+void ThreadActivityTracker::PopActivity(const void* source) {
+  // Do an atomic decrement of the depth. No changes to stack entries guarded
+  // by this variable is done here so a "relaxed" operation is acceptable.
+  // |depth| will receive the value before it was modified.
+  uint32_t depth = header_->depth.fetch_sub(1, std::memory_order_relaxed);
+
+  // Validate that everything is running correctly.
+  DCHECK_LT(0U, depth);
+  if (depth <= stack_slots_) {
+    DCHECK_EQ(reinterpret_cast<uintptr_t>(source),
+              stack_[depth - 1].source_address);
+    DCHECK(stack_[depth - 1].activity_type == ACT_LOCK ||
+           thread_checker_.CalledOnValidThread());
+  }
+
+  // The stack has shrunk meaning that some other thread trying to copy the
+  // contents for reporting purposes could get bad data. That thread would
+  // have written a non-zero value into |unchanged|; clearing it here will
+  // let that thread detect that something did change. It doesn't matter
+  // when this is done relative to the atomic |depth| operation above so a
+  // "relaxed" access is acceptable.
+  header_->unchanged.store(0, std::memory_order_relaxed);
+}
+
+// static
+size_t ThreadActivityTracker::SizeForStackDepth(int stack_depth) {
+  return static_cast<size_t>(stack_depth) * sizeof(StackEntry) + sizeof(Header);
+}
+
+ThreadActivityAnalyzer::ThreadActivityAnalyzer(ThreadActivityTracker* tracker)
+    : ThreadActivityAnalyzer(
+          tracker->header_,
+          ThreadActivityTracker::SizeForStackDepth(tracker->stack_slots_)) {}
+
+ThreadActivityAnalyzer::ThreadActivityAnalyzer(
+    PersistentMemoryAllocator* allocator,
+    PersistentMemoryAllocator::Reference reference)
+    : ThreadActivityAnalyzer(allocator->GetAsObject<char>(
+                                 reference,
+                                 GlobalActivityTracker::kTypeIdActivityTracker),
+                             allocator->GetAllocSize(reference)) {}
+
+ThreadActivityAnalyzer::ThreadActivityAnalyzer(void* base, size_t size)
+    : tracker_(base, size) {}
+
+ThreadActivityAnalyzer::~ThreadActivityAnalyzer() {}
+
+uint32_t ThreadActivityAnalyzer::SnapshotStack(
+    std::vector<StackEntry>* snapshot) {
+  // It's possible for the data to change while reading it in such a way that it
+  // invalidates the read. Make several attempts but don't try forever.
+  const int kMaxAttempts = 10;
+  uint32_t depth;
+
+  // Start with an empty return stack.
+  snapshot->clear();
+
+  // Stop here if the data isn't valid.
+  if (!tracker_.is_valid())
+    return 0;
+
+  ThreadActivityTracker::Header* header = tracker_.header_;
+  for (int attempt = 0; attempt < kMaxAttempts; ++attempt) {
+    // Write a non-zero value to |unchanged| so it's possible to detect at
+    // the end that nothing has changed since copying the data began.
+    header->unchanged.store(1, std::memory_order_relaxed);
+
+    // Fetching the current depth also "acquires" the contents of the stack.
+    depth = header->depth.load(std::memory_order_acquire);
+    if (depth == 0)
+      return 0;
+
+    // Copy the existing contents. Memcpy is used for speed.
+    uint32_t count = std::min(depth, tracker_.stack_slots_);
+    snapshot->resize(count);
+    memcpy(&(*snapshot)[0], tracker_.stack_, count * sizeof(StackEntry));
+
+    // Check to make sure everything was unchanged during the copy.
+    if (header->unchanged.load(std::memory_order_relaxed))
+      return depth;
+  }
+
+  // If all attempts failed, just return the depth with no content.
+  snapshot->clear();
+  return depth;
+}
+
+
+GlobalActivityTracker* GlobalActivityTracker::g_tracker_ = nullptr;
+
+GlobalActivityTracker::ManagedActivityTracker::ManagedActivityTracker(
+    PersistentMemoryAllocator::Reference mem_reference,
+    void* base,
+    size_t size)
+    : ThreadActivityTracker(base, size),
+      mem_reference_(mem_reference),
+      mem_base_(base) {}
+
+GlobalActivityTracker::ManagedActivityTracker::~ManagedActivityTracker() {
+  // The global |g_tracker_| must point to the owner of this class since all
+  // objects of this type must be destructed before |g_tracker_| can be changed
+  // (something that only occurs in tests).
+  DCHECK(g_tracker_);
+  g_tracker_->ReturnTrackerMemory(this, mem_reference_, mem_base_);
+}
+
+void GlobalActivityTracker::CreateWithAllocator(
+    std::unique_ptr<PersistentMemoryAllocator> allocator,
+    int stack_depth) {
+  // There's no need to do anything with the result. It is self-managing.
+  new GlobalActivityTracker(std::move(allocator), stack_depth);
+}
+
+// static
+void GlobalActivityTracker::CreateWithLocalMemory(size_t size,
+                                                  uint64_t id,
+                                                  StringPiece name,
+                                                  int stack_depth) {
+  CreateWithAllocator(
+      WrapUnique(new LocalPersistentMemoryAllocator(size, id, name)),
+      stack_depth);
+}
+
+#if !defined(OS_NACL)
+// static
+void GlobalActivityTracker::CreateWithFile(const FilePath& file_path,
+                                           size_t size,
+                                           uint64_t id,
+                                           StringPiece name,
+                                           int stack_depth) {
+  DCHECK(!file_path.empty());
+
+  // Create the file, overwriting anything that was there previously, and set
+  // the length. This will create a space that is zero-filled, a requirement
+  // for operation.
+  File file(file_path, File::FLAG_CREATE_ALWAYS | File::FLAG_READ |
+                       File::FLAG_WRITE | File::FLAG_SHARE_DELETE);
+  DCHECK(file.IsValid());
+  file.SetLength(size);
+
+  // Map the file into memory and make it globally available.
+  std::unique_ptr<MemoryMappedFile> mapped_file(new MemoryMappedFile());
+  bool success =
+      mapped_file->Initialize(std::move(file), MemoryMappedFile::READ_WRITE);
+  DCHECK(success);
+  CreateWithAllocator(WrapUnique(new FilePersistentMemoryAllocator(
+                          std::move(mapped_file), size, id, name, false)),
+                      stack_depth);
+}
+#endif  // !defined(OS_NACL)
+
+ThreadActivityTracker* GlobalActivityTracker::CreateTrackerForCurrentThread() {
+  DCHECK(!this_thread_tracker_.Get());
+
+  PersistentMemoryAllocator::Reference mem_reference = 0;
+  void* mem_base = nullptr;
+
+  // Get the current count of available memories, acquiring the array values.
+  int count = available_memories_count_.load(std::memory_order_acquire);
+  while (count > 0) {
+    // There is a memory block that was previously released (and zero'd) so
+    // just re-use that rather than allocating a new one.
+    mem_reference =
+        available_memories_[count - 1].load(std::memory_order_relaxed);
+    DCHECK(mem_reference);
+
+    // Decrement the count indicating that the value has been taken. If this
+    // fails then something else, another thread doing push or pop, has changed
+    // the stack; retry if so. |count| will receive the existing value.
+    if (!available_memories_count_.compare_exchange_weak(
+            count, count - 1,
+            std::memory_order_acquire, std::memory_order_acquire)) {
+      continue;
+    }
+
+    // Clear the value just read from the array so that the "push" operation
+    // knows there is no value there and will work correctly.
+    available_memories_[count - 1].store(0, std::memory_order_relaxed);
+
+    // Turn the reference back into one of the activity-tracker type.
+    mem_base = allocator_->GetAsObject<char>(mem_reference,
+                                             kTypeIdActivityTrackerFree);
+    DCHECK(mem_base);
+    DCHECK_LE(stack_memory_size_, allocator_->GetAllocSize(mem_reference));
+    allocator_->SetType(mem_reference, kTypeIdActivityTracker);
+
+    // Success.
+    break;
+  }
+
+  if (count == 0) {
+    // Allocate a block of memory from the persistent segment.
+    mem_reference =
+        allocator_->Allocate(stack_memory_size_, kTypeIdActivityTracker);
+    if (mem_reference) {
+      // Success. Convert the reference to an actual memory address.
+      mem_base =
+          allocator_->GetAsObject<char>(mem_reference, kTypeIdActivityTracker);
+      // Make the allocation iterable so it can be found by other processes.
+      allocator_->MakeIterable(mem_reference);
+    } else {
+      // Failure. This should never happen.

[manzagop (departed), 2016/06/01 21:59:40]

It can if we didn't plan for enough memory, right?

[bcwhite, 2016/06/02 16:18:16]

Right.  I'll add to the comment.

+      NOTREACHED();
+      // But if it does, handle it gracefully by allocating the required
+      // memory from the heap.
+      mem_base = new char[stack_memory_size_];
+      memset(mem_base, 0, stack_memory_size_);
+    }
+  }
+
+  // Create a tracker with the acquired memory and set it as the tracker
+  // for this particular thread in thread-local-storage.
+  DCHECK(mem_base);
+  ManagedActivityTracker* tracker =
+      new ManagedActivityTracker(mem_reference, mem_base, stack_memory_size_);
+  DCHECK(tracker->is_valid());
+  this_thread_tracker_.Set(tracker);
+  thread_tracker_count_.fetch_add(1, std::memory_order_relaxed);
+
+  return tracker;
+}
+
+void GlobalActivityTracker::ReleaseTrackerForCurrentThreadForTesting() {
+  ThreadActivityTracker* tracker =
+      reinterpret_cast<ThreadActivityTracker*>(this_thread_tracker_.Get());
+  if (tracker) {
+    this_thread_tracker_.Free();
+    delete tracker;
+  }
+}
+
+GlobalActivityTracker::GlobalActivityTracker(
+    std::unique_ptr<PersistentMemoryAllocator> allocator,
+    int stack_depth)
+    : allocator_(std::move(allocator)),
+      stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
+      this_thread_tracker_(&OnTLSDestroy),
+      thread_tracker_count_(0),
+      available_memories_count_(0) {
+  // Clear the available-memories array.
+  memset(available_memories_, 0, sizeof(available_memories_));
+
+  // Ensure the passed memory is valid and empty (iterator finds nothing).
+  uint32_t type;
+  DCHECK(!PersistentMemoryAllocator::Iterator(allocator_.get()).GetNext(&type));
+
+  // Ensure that there is no other global object and then make this one such.
+  DCHECK(!g_tracker_);
+  g_tracker_ = this;
+
+  // Create a tracker for this thread since it is known.
+  CreateTrackerForCurrentThread();
+}
+
+GlobalActivityTracker::~GlobalActivityTracker() {
+  DCHECK_EQ(g_tracker_, this);
+  DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
+  g_tracker_ = nullptr;
+}
+
+void GlobalActivityTracker::ReturnTrackerMemory(
+    ManagedActivityTracker* tracker,
+    PersistentMemoryAllocator::Reference mem_reference,
+    void* mem_base) {
+  // Zero the memory so that it is ready for use if needed again later. It's
+  // better to clear the memory now, when a thread is exiting, than to do it
+  // when it is first needed by a thread doing actual work.
+  memset(mem_base, 0, stack_memory_size_);
+
+  // Remove the destructed tracker from the set of known ones.
+  DCHECK_LE(1, thread_tracker_count_.load(std::memory_order_relaxed));
+  thread_tracker_count_.fetch_sub(1, std::memory_order_relaxed);
+
+  // Deal with the memory that was used by the tracker.
+  if (mem_reference) {
+    // The memory was within the persistent memory allocator. Change its type
+    // so that iteration won't find it.
+    allocator_->SetType(mem_reference, kTypeIdActivityTrackerFree);
+    // There is no way to free memory from a persistent allocator so instead
+    // push it on the internal list of available memory blocks.
+    while (true) {
+      // Get the existing count of available memories and ensure we won't
+      // burst the array. Acquire the values in the array.
+      int count = available_memories_count_.load(std::memory_order_acquire);
+      if (count >= kMaxThreadCount) {
+        NOTREACHED();
+        // Storage is full. Just forget about this memory. It won't be re-used
+        // but there's no real loss.
+        break;
+      }
+
+      // Write the reference of the memory being returned to this slot in the
+      // array. Empty slots have a value of zero so do an atomic compare-and-
+      // exchange to ensure that a race condition doesn't exist with another
+      // thread doing the same.
+      PersistentMemoryAllocator::Reference mem_expected = 0;
+      if (!available_memories_[count].compare_exchange_weak(
+              mem_expected, mem_reference,
+              std::memory_order_release, std::memory_order_relaxed)) {
+        continue;  // Try again.
+      }
+
+      // Increment the count, releasing the value written to the array. This
+      // could fail if a simultaneous "pop" operation decremented the counter.
+      // If that happens, clear the array slot and start over. Do a "strong"
+      // exchange to avoid spurious retries that can occur with a "weak" one.
+      int expected = count;  // Updated by compare/exchange.
+      if (!available_memories_count_.compare_exchange_strong(
+              expected, count + 1,
+              std::memory_order_release, std::memory_order_relaxed)) {
+        available_memories_[count].store(0, std::memory_order_relaxed);
+        continue;
+      }
+
+      // Count was successfully incremented to refrect the new value added.

[manzagop (departed), 2016/06/01 21:59:41]

typo: reflect

[bcwhite, 2016/06/02 16:18:16]

Done.

+      break;
+    }
+  } else {
+    // The memory was allocated from the process heap. This shouldn't happen
+    // because the persistent memory segment should be big enough for all
+    // thread stacks but it's better to support falling back to allocation
+    // from the heap rather than crash. Everything will work as normal but
+    // the data won't be persisted.
+    delete[] reinterpret_cast<char*>(mem_base);
+  }
+}
+
+// static
+void GlobalActivityTracker::OnTLSDestroy(void* value) {
+  delete reinterpret_cast<ManagedActivityTracker*>(value);
+}
+
+
+ScopedTaskActivity::ScopedTaskActivity(const base::PendingTask& task)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          task.posted_from.program_counter(),
+          ThreadActivityTracker::ACT_TASK,
+          ThreadActivityTracker::StackEntryData::ForTask(task.sequence_num),
+          /*lock_allowed=*/true) {}
+
+ScopedLockActivity::ScopedLockActivity(const base::internal::LockImpl* lock)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          nullptr,
+          ThreadActivityTracker::ACT_LOCK,
+          ThreadActivityTracker::StackEntryData::ForLock(lock),
+          /*lock_allowed=*/false) {}
+
+ScopedEventActivity::ScopedEventActivity(const base::WaitableEvent* event)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          nullptr,
+          ThreadActivityTracker::ACT_EVENT,
+          ThreadActivityTracker::StackEntryData::ForEvent(event),
+          /*lock_allowed=*/true) {}
+
+}  // namespace debug
+}  // namespace base