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/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() {

[Alexei Svitkine (slow), 2017/02/06 17:46:12]

What prevents this being called after Record() has already added something to
global_data()?

[bcwhite, 2017/02/07 15:58:58]

Nothing.  Data before that point will be recorded, if a GlobalActivityTracker
got created, but not after.  No harm.

[Alexei Svitkine (slow), 2017/02/07 16:14:06]

Can you document that? In practice, I guess this means that whatever trials we
check before and including the trial that's controlling the Feature in question
will always be recorded?

[bcwhite, 2017/02/07 17:39:30]

They can't be recorded until a global tracker is created.  Generally, it'll
either be created or field-trial tracking will be disabled but not both.  The
result is that early field-trial activations will get held in temporary space
and then discarded when Disable is called.

+    enabled_.store(false, std::memory_order_relaxed);
+    AutoLock lock(trial_group_lock_);
+    trial_group_map_.clear();
+  }
+
+  void DumpCollectedActivity() {
+    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, StringPiece 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.as_string()));

[Alexei Svitkine (slow), 2017/02/06 17:46:12]

group_name is being turned back into a string here, making the param being a
StringPiece worse than if it was a string ref. Use a string ref instead.

[bcwhite, 2017/02/07 15:58:58]

This isn't the usual case, though.  Normal activity will run through the case
above which doesn't turn it back into a std::string.

However, since we know where it's being called from and that it's a std::string
there, might as well make use of that.

Done.

+    }
+  }
+
+ 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 741 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,
+                                             StringPiece 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_);
   g_tracker_ = 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(g_tracker_, this);
   DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
   g_tracker_ = nullptr;
 }
 
 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