Fix some issues with atomics in the activity tracker.

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 <algorithm>
 #include <limits>
 #include <utility>
 
+#include "base/atomic_sequence_num.h"
 #include "base/debug/stack_trace.h"
 #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/metrics/histogram_macros.h"
 #include "base/pending_task.h"
 #include "base/pickle.h"
@@ skipping 225 matching lines @@
 
 StringPiece ActivityUserData::TypedValue::GetStringReference() const {
   DCHECK_EQ(STRING_VALUE_REFERENCE, type_);
   return ref_value_;
 }
 
 ActivityUserData::ValueInfo::ValueInfo() {}
 ActivityUserData::ValueInfo::ValueInfo(ValueInfo&&) = default;
 ActivityUserData::ValueInfo::~ValueInfo() {}
 
-std::atomic<uint32_t> ActivityUserData::next_id_;
+StaticAtomicSequenceNumber ActivityUserData::next_id_;
 
 ActivityUserData::ActivityUserData(void* memory, size_t size)
     : memory_(reinterpret_cast<char*>(memory)),
       available_(RoundDownToAlignment(size, kMemoryAlignment)),
       id_(reinterpret_cast<std::atomic<uint32_t>*>(memory)) {
   // It's possible that no user data is being stored.
   if (!memory_)
     return;
 
   DCHECK_LT(kMemoryAlignment, available_);
   if (id_->load(std::memory_order_relaxed) == 0) {
     // Generate a new ID and store it in the first 32-bit word of memory_.
     // |id_| must be non-zero for non-sink instances.
     uint32_t id;
-    while ((id = next_id_.fetch_add(1, std::memory_order_relaxed)) == 0)
+    while ((id = next_id_.GetNext()) == 0)
       ;
     id_->store(id, std::memory_order_relaxed);
     DCHECK_NE(0U, id_->load(std::memory_order_relaxed));
   }
   memory_ += kMemoryAlignment;
   available_ -= kMemoryAlignment;
 
   // If there is already data present, load that. This allows the same class
   // to be used for analysis through snapshots.
   ImportExistingData();
@@ skipping 610 matching lines @@
 
   // Too many attempts.
   return false;
 }
 
 // static
 size_t ThreadActivityTracker::SizeForStackDepth(int stack_depth) {
   return static_cast<size_t>(stack_depth) * sizeof(Activity) + sizeof(Header);
 }
 
-
-GlobalActivityTracker* GlobalActivityTracker::g_tracker_ = nullptr;
+// The instantiation of the GlobalActivityTracker object.
+// The object held here will obviously not be destructed at process exit
+// but that's best since PersistentMemoryAllocator objects (that underlie
+// GlobalActivityTracker objects) are explicitly forbidden from doing anything
+// essential at exit anyway due to the fact that they depend on data managed
+// elsewhere and which could be destructed first. An AtomicWord is used instead
+// of std::atomic because the latter can create global ctors and dtors.
+subtle::AtomicWord GlobalActivityTracker::g_tracker_ = 0;
 
 GlobalActivityTracker::ModuleInfo::ModuleInfo() {}
 GlobalActivityTracker::ModuleInfo::ModuleInfo(ModuleInfo&& rhs) = default;
 GlobalActivityTracker::ModuleInfo::ModuleInfo(const ModuleInfo& rhs) = default;
 GlobalActivityTracker::ModuleInfo::~ModuleInfo() {}
 
 GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
     ModuleInfo&& rhs) = default;
 GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
     const ModuleInfo& rhs) = default;
@@ skipping 141 matching lines @@
     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);
+  GlobalActivityTracker::Get()->ReturnTrackerMemory(this);
 }
 
 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.
   GlobalActivityTracker* global_tracker =
       new GlobalActivityTracker(std::move(allocator), stack_depth);
   // Create a tracker for this thread since it is known.
   global_tracker->CreateTrackerForCurrentThread();
@@ skipping 157 matching lines @@
               allocator_->Allocate(kGlobalDataSize, kTypeIdGlobalDataRecord),
               kTypeIdGlobalDataRecord,
               PersistentMemoryAllocator::kSizeAny),
           kGlobalDataSize) {
   // 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;
+  subtle::NoBarrier_Store(&g_tracker_, reinterpret_cast<uintptr_t>(this));
 
   // The global records must be iterable in order to be found by an analyzer.
   allocator_->MakeIterable(allocator_->GetAsReference(
       user_data_.GetBaseAddress(), kTypeIdGlobalDataRecord));
 }
 
 GlobalActivityTracker::~GlobalActivityTracker() {
-  DCHECK_EQ(g_tracker_, this);
+  DCHECK_EQ(Get(), this);
   DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
-  g_tracker_ = nullptr;
+  subtle::NoBarrier_Store(&g_tracker_, 0);
 }
 
 void GlobalActivityTracker::ReturnTrackerMemory(
     ManagedActivityTracker* tracker) {
   PersistentMemoryAllocator::Reference mem_reference = tracker->mem_reference_;
   void* mem_base = tracker->mem_base_;
   DCHECK(mem_reference);
   DCHECK(mem_base);
 
   // Remove the destructed tracker from the set of known ones.
@@ skipping 88 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base