New cache for the activity tracker.

base/debug/activity_tracker.h

 // 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.
 
 // Activity tracking provides a low-overhead method of collecting information
 // about the state of the application for analysis both while it is running
 // and after it has terminated unexpectedly. Its primary purpose is to help
 // locate reasons the browser becomes unresponsive by providing insight into
 // what all the various threads and processes are (or were) doing.
 
 #ifndef BASE_DEBUG_ACTIVITY_TRACKER_H_
 #define BASE_DEBUG_ACTIVITY_TRACKER_H_
 
 // std::atomic is undesired due to performance issues when used as global
 // variables. There are no such instances here. This module uses the
 // PersistentMemoryAllocator which also uses std::atomic and is written
 // by the same author.
 #include <atomic>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/location.h"
 #include "base/metrics/persistent_memory_allocator.h"
+#include "base/threading/platform_thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 
 struct PendingTask;
 
 class FilePath;
 class Lock;
 class MemoryMappedFile;
 class PlatformThreadHandle;
 class Process;
 class WaitableEvent;
 
 namespace debug {
 
 class ThreadActivityTracker;
 
+
 enum : int {
   // The maximum number of call-stack addresses stored per activity. This
   // cannot be changed without also changing the version number of the
   // structure. See kTypeIdActivityTracker in GlobalActivityTracker.
   kActivityCallStackSize = 10,
 };
 
 // The data associated with an activity is dependent upon the activity type.
 // This union defines all of the various fields. All fields must be explicitly
 // sized types to ensure no interoperability problems between 32-bit and
@@ skipping 281 matching lines @@
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadActivityTracker);
 };
 
 
 // The global tracker manages all the individual thread trackers. Memory for
 // the thread trackers is taken from a PersistentMemoryAllocator which allows
 // for the data to be analyzed by a parallel process or even post-mortem.
 class BASE_EXPORT GlobalActivityTracker {
+  template <typename T>
+  class ThreadSafeStack {
+   public:
+    ThreadSafeStack(size_t size)
+        : size_(size), values_(new T[size]), used_(0) {}
+    ~ThreadSafeStack() {}
+
+    size_t size() { return size_; }
+    size_t used() {
+      base::AutoLock autolock(lock_);
+      return used_;
+    }
+
+    bool push(T value) {
+      base::AutoLock autolock(lock_);
+      if (used_ == size_)
+        return false;
+      values_[used_++] = value;
+      return true;
+    }
+
+    bool pop(T* out_value) {
+      base::AutoLock autolock(lock_);
+      if (used_ == 0)
+        return false;
+      *out_value = values_[--used_];
+      return true;
+    }
+
+   private:
+    const size_t size_;
+
+    std::unique_ptr<T[]> values_;
+    size_t used_;
+    base::Lock lock_;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(ThreadSafeStack);
+  };
+
  public:
   // Type identifiers used when storing in persistent memory so they can be
   // identified during extraction; the first 4 bytes of the SHA1 of the name
   // is used as a unique integer. A "version number" is added to the base
   // so that, if the structure of that object changes, stored older versions
   // will be safely ignored. These are public so that an external process
   // can recognize records of this type within an allocator.
   enum : uint32_t {
     kTypeIdActivityTracker     = 0x5D7381AF + 1,  // SHA1(ActivityTracker) v1
     kTypeIdActivityTrackerFree = 0x3F0272FB + 1,  // SHA1(ActivityTrackerFree)
@@ skipping 143 matching lines @@
   // is taken.
   std::unique_ptr<PersistentMemoryAllocator> allocator_;
 
   // The size (in bytes) of memory required by a ThreadActivityTracker to
   // provide the stack-depth requested during construction.
   const size_t stack_memory_size_;
 
   // The activity tracker for the currently executing thread.
   base::ThreadLocalStorage::Slot this_thread_tracker_;
 
-  // These have to be lock-free because lock activity is tracked and causes
-  // re-entry problems.
+  // The number of thread trackers currently active.
   std::atomic<int> thread_tracker_count_;
-  std::atomic<int> available_memories_count_;
-  std::atomic<PersistentMemoryAllocator::Reference>
-      available_memories_[kMaxThreadCount];
+
+  // A cache of thread-tracker memories that have been previously freed and
+  // thus can be re-used instead of allocating new ones.
+  ThreadSafeStack<PersistentMemoryAllocator::Reference> available_memories_;
 
   // The active global activity tracker.
   static GlobalActivityTracker* g_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(GlobalActivityTracker);
 };
 
 
 // Record entry in to and out of an arbitrary block of code.
 class BASE_EXPORT ScopedActivity
@@ skipping 83 matching lines @@
   explicit ScopedProcessWaitActivity(const base::Process* process);
  private:
   DISALLOW_COPY_AND_ASSIGN(ScopedProcessWaitActivity);
 };
 #endif
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_ACTIVITY_TRACKER_H_