Record field-trial information in stability file for crash analysis.

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/lazy_instance.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"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.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 4 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 uint32_t kHeaderCookie = 0xC0029B24UL + 2;  // v2
 
 // The minimum depth a stack should support.
 const int kMinStackDepth = 2;
 
 // The amount of memory set aside for holding arbitrary user data (key/value
 // pairs) globally or associated with ActivityData entries.
-const size_t kUserDataSize = 1024;    // bytes
-const size_t kGlobalDataSize = 4096;  // bytes
+const size_t kUserDataSize = 1 << 10;     // 1 KiB
+const size_t kGlobalDataSize = 16 << 10;  // 16 KiB
 const size_t kMaxUserDataNameLength =
     static_cast<size_t>(std::numeric_limits<uint8_t>::max());
 
 // A constant used to indicate that module information is changing.
 const uint32_t kModuleInformationChanging = 0x80000000;
 
 union ThreadRef {
   int64_t as_id;
 #if defined(OS_WIN)
   // On Windows, the handle itself is often a pseudo-handle with a common
   // value meaning "this thread" and so the thread-id is used. The former
   // can be converted to a thread-id with a system call.
   PlatformThreadId as_tid;
 #elif defined(OS_POSIX)
   // On Posix, the handle is always a unique identifier so no conversion
   // needs to be done. However, it's value is officially opaque so there
   // is no one correct way to convert it to a numerical identifier.
   PlatformThreadHandle::Handle as_handle;
 #endif
 };
 
+// A class to collect field-trial information and dump it to a global
+// tracker. If no GlobalActivityTracker exists, the information is held
+// locally for dumping later.
+class FieldTrialRecorder {
+ public:
+  FieldTrialRecorder() : enabled_(true) {}
+  ~FieldTrialRecorder() {}
+
+  void Disable() {
+    enabled_.store(false, std::memory_order_relaxed);
+    AutoLock lock(trial_group_lock_);
+    trial_group_map_.clear();
+  }
+
+  void DumpCollectedActivity() {

[Alexei Svitkine (slow), 2017/02/07 19:28:10]

Thinking about this more, I think we can simplify this much more by not having
this extra FieldTrialRecorder class.

Right now, you monitor for field trial activations even before the global object
has been created and then have this Dump call to synchronize it.

Instead, I propose the following:
  - When GlobalTracker is created, instead of the Dump call from this
intermediate object, it queries the current activated state from the FieldTrial
system.
  - Calls to base::debug::GlobalActivityTracker::RecordFieldTrial() are no-ops
before the GlobalTracker exists and once it does they start update the full
state.

This way, no need for FieldTrialRecorded and no need for extra intermediate
state or any special Disable functionality.

You can get the active field trial groups via GetActiveFieldTrialGroups() when
the activity tracker is created.

[bcwhite, 2017/02/07 21:18:03]

Done.

+    DCHECK(GlobalActivityTracker::Get());
+
+    // OnFieldTrialGroupFinalized will insert into trial_group_map_ if the
+    // global tracker goes away. Be safe and move its contents to a local
+    // variable first.
+    std::map<std::string, std::string> collected;
+    {
+      AutoLock lock(trial_group_lock_);
+      collected.swap(trial_group_map_);
+    }
+
+    // Store collected information to the global tracker.
+    for (const auto& kv : collected)
+      Record(kv.first, kv.second);
+  }
+
+  void Record(const std::string& trial_name, const std::string& group_name) {
+    if (!enabled_.load(std::memory_order_relaxed))
+      return;
+
+    const std::string key = std::string("FieldTrial.") + trial_name;
+
+    GlobalActivityTracker* tracker = GlobalActivityTracker::Get();
+    if (tracker) {
+      // global_data is thread-safe.
+      tracker->global_data().SetString(key, group_name);
+    } else {
+      AutoLock lock(trial_group_lock_);
+      trial_group_map_.insert(std::make_pair(key, group_name));
+    }
+  }
+
+ private:
+  std::atomic<bool> enabled_;
+  std::map<std::string, std::string> trial_group_map_;
+  Lock trial_group_lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(FieldTrialRecorder);
+};
+
+LazyInstance<FieldTrialRecorder>::Leaky g_field_trial_recorder =
+    LAZY_INSTANCE_INITIALIZER;
+
 // Determines the previous aligned index.
 size_t RoundDownToAlignment(size_t index, size_t alignment) {
   return index & (0 - alignment);
 }
 
 // Determines the next aligned index.
 size_t RoundUpToAlignment(size_t index, size_t alignment) {
   return (index + (alignment - 1)) & (0 - alignment);
 }
 
@@ skipping 204 matching lines @@
   // to be used for analysis through snapshots.
   ImportExistingData();
 }
 
 ActivityUserData::~ActivityUserData() {}
 
 void ActivityUserData::Set(StringPiece name,
                            ValueType type,
                            const void* memory,
                            size_t size) {
-  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_GE(std::numeric_limits<uint8_t>::max(), name.length());
   size = std::min(std::numeric_limits<uint16_t>::max() - (kMemoryAlignment - 1),
                   size);
 
   // It's possible that no user data is being stored.
   if (!memory_)
     return;
 
   // The storage of a name is limited so use that limit during lookup.
   if (name.length() > kMaxUserDataNameLength)
@@ skipping 747 matching lines @@
       AutoLock lock(global->user_data_allocator_lock_);
       user_data_ =
           tracker_->GetUserData(activity_id_, &global->user_data_allocator_);
     } else {
       user_data_ = MakeUnique<ActivityUserData>(nullptr, 0);
     }
   }
   return *user_data_;
 }
 
+GlobalActivityTracker::GlobalUserData::GlobalUserData(void* memory, size_t size)
+    : ActivityUserData(memory, size) {}
+
+GlobalActivityTracker::GlobalUserData::~GlobalUserData() {}
+
+void GlobalActivityTracker::GlobalUserData::Set(StringPiece name,
+                                                ValueType type,
+                                                const void* memory,
+                                                size_t size) {
+  AutoLock lock(data_lock_);
+  ActivityUserData::Set(name, type, memory, size);
+}
+
 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
@@ skipping 140 matching lines @@
       allocator_->AllocateObject<ModuleInfoRecord>(required_size);
   if (!record)
     return;
 
   bool success = record->EncodeFrom(info, required_size);
   DCHECK(success);
   allocator_->MakeIterable(record);
   modules_.insert(std::make_pair(info.file, record));
 }
 
+// static
+void GlobalActivityTracker::RecordFieldTrial(const std::string& trial_name,
+                                             const std::string& group_name) {
+  g_field_trial_recorder.Get().Record(trial_name, group_name);
+}
+
+// static
+void GlobalActivityTracker::DisableFieldTrialRecording() {
+  g_field_trial_recorder.Get().Disable();
+}
+
 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),
       thread_tracker_allocator_(allocator_.get(),
                                 kTypeIdActivityTracker,
                                 kTypeIdActivityTrackerFree,
                                 stack_memory_size_,
                                 kCachedThreadMemories,
                                 /*make_iterable=*/true),
       user_data_allocator_(allocator_.get(),
                            kTypeIdUserDataRecord,
                            kTypeIdUserDataRecordFree,
                            kUserDataSize,
                            kCachedUserDataMemories,
                            /*make_iterable=*/false),
-      user_data_(
+      global_data_(
           allocator_->GetAsArray<char>(
               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_);
   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));
+      global_data_.GetBaseAddress(), kTypeIdGlobalDataRecord));
+
+  // Enable tracking (if not done previously) and dump previously collected
+  // field-trial information to this global tracker.
+  g_field_trial_recorder.Get().DumpCollectedActivity();
 }
 
 GlobalActivityTracker::~GlobalActivityTracker() {
   DCHECK_EQ(Get(), this);
   DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
   subtle::NoBarrier_Store(&g_tracker_, 0);
 }
 
 void GlobalActivityTracker::ReturnTrackerMemory(
     ManagedActivityTracker* tracker) {
@@ skipping 94 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base