Use SharedPersistentMemoryAllocator to share field trial state

base/metrics/field_trial.cc

 // Copyright (c) 2012 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/metrics/field_trial.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/base_switches.h"
@@ skipping 17 matching lines @@
 const char kPersistentStringSeparator = '/';  // Currently a slash.
 
 // Define a marker character to be used as a prefix to a trial name on the
 // command line which forces its activation.
 const char kActivationMarker = '*';
 
 // Use shared memory to communicate field trial (experiment) state. Set to false
 // for now while the implementation is fleshed out (e.g. data format, single
 // shared memory segment). See https://codereview.chromium.org/2365273004/ and
 // crbug.com/653874
-#if defined(OS_WIN)
 const bool kUseSharedMemoryForFieldTrials = false;
-#endif
+
+// Constants for the field trial allocator.
+const char kAllocatorName[] = "field_trial_allocator";
+const uint32_t kFieldTrialType = 0xABA17E13 + 1;  // Version #1 of type

[bcwhite, 2016/10/14 14:23:46]

// SHA1(FieldTrialEntry) v1

So that others know where this number comes from.

[lawrencewu, 2016/10/19 16:21:28]

Done.

+
+// We create one FieldTrialEntry struct per field trial in shared memory (via
+// field_trial_allocator). It contains whether or not it's activated, and the
+// offset from the start of the allocated memory to the group name. We don't
+// need the offset into the trial name because that's always a fixed position
+// from the start of the struct. Two strings will be appended to the end of this
+// structure in allocated memory, so the result will look like this:
+// ---------------------------------
+// | fte | trial_name | group_name |
+// ---------------------------------
+struct FieldTrialEntry {
+  bool activated;
+  uint32_t group_name_offset;
+};
+
+char* GetTrialName(FieldTrialEntry* fte) {

[Alexei Svitkine (slow), 2016/10/17 14:46:50]

Make this actually a member of FieldTrialEntry - i.e. a struct can have methods
just like a class.

Then, you don't need |fte| parameter, because you can use |this|.

[lawrencewu, 2016/10/19 16:21:28]

Done.

+  char* src = (char*)fte;

[Alexei Svitkine (slow), 2016/10/17 14:46:50]

Per the style guide, you must use C++ style casts rather than C casts.

[lawrencewu, 2016/10/19 16:21:28]

Done.

+  return src + sizeof(FieldTrialEntry);
+}
+
+char* GetGroupName(FieldTrialEntry* fte) {
+  char* src = (char*)fte;
+  return src + fte->group_name_offset;
+}
 
 // Created a time value based on |year|, |month| and |day_of_month| parameters.
 Time CreateTimeFromParams(int year, int month, int day_of_month) {
   DCHECK_GT(year, 1970);
   DCHECK_GT(month, 0);
   DCHECK_LT(month, 13);
   DCHECK_GT(day_of_month, 0);
   DCHECK_LT(day_of_month, 32);
 
   Time::Exploded exploded;
@@ skipping 74 matching lines @@
 }
 
 }  // namespace
 
 // statics
 const int FieldTrial::kNotFinalized = -1;
 const int FieldTrial::kDefaultGroupNumber = 0;
 bool FieldTrial::enable_benchmarking_ = false;
 
 int FieldTrialList::kNoExpirationYear = 0;
+base::SharedPersistentMemoryAllocator* FieldTrialList::field_trial_allocator =
+    nullptr;
 
 //------------------------------------------------------------------------------
 // FieldTrial methods and members.
 
 FieldTrial::EntropyProvider::~EntropyProvider() {
 }
 
 FieldTrial::State::State() : activated(false) {}
 
 FieldTrial::State::State(const State& other) = default;
@@ skipping 425 matching lines @@
 
 // static
 void FieldTrialList::CreateTrialsFromCommandLine(
     const base::CommandLine& cmd_line,
     const char* field_trial_handle_switch) {
   DCHECK(global_);
 
 #if defined(OS_WIN)
   if (cmd_line.HasSwitch(field_trial_handle_switch)) {
     std::string arg = cmd_line.GetSwitchValueASCII(field_trial_handle_switch);
-    size_t token = arg.find(",");
-    int field_trial_handle = std::stoi(arg.substr(0, token));
-    int field_trial_length = std::stoi(arg.substr(token + 1, arg.length()));
+    int field_trial_handle = std::stoi(arg);
 
     HANDLE handle = reinterpret_cast<HANDLE>(field_trial_handle);
     base::SharedMemoryHandle shm_handle =
         base::SharedMemoryHandle(handle, base::GetCurrentProcId());
 
     // Gets deleted when it gets out of scope, but that's OK because we need it
-    // only for the duration of this call currently anyway.
-    base::SharedMemory shared_memory(shm_handle, false);
-    shared_memory.Map(field_trial_length);
+    // only for the duration of this method.
+    std::unique_ptr<base::SharedMemory> shm(
+        new base::SharedMemory(shm_handle, false));
+    shm.get()->Map(4 << 10);  // 4 KiB = one page
 
-    char* field_trial_state = static_cast<char*>(shared_memory.memory());
-    bool result = FieldTrialList::CreateTrialsFromString(
-        std::string(field_trial_state), std::set<std::string>());
-    DCHECK(result);
+    FieldTrialList::CreateTrialsFromSharedMemory(std::move(shm));
     return;
   }
 #endif
 
   if (cmd_line.HasSwitch(switches::kForceFieldTrials)) {
     bool result = FieldTrialList::CreateTrialsFromString(
         cmd_line.GetSwitchValueASCII(switches::kForceFieldTrials),
         std::set<std::string>());
     DCHECK(result);
   }
 }
 
+#if defined(OS_WIN)
+// static
+void FieldTrialList::AppendFieldTrialHandleIfNeeded(
+    base::HandlesToInheritVector& handles) {
+  if (field_trial_allocator) {
+    handles.push_back(
+        field_trial_allocator->shared_memory()->handle().GetHandle());
+  }
+}
+#endif
+
+// static
+void FieldTrialList::CreateTrialsFromSharedMemory(
+    std::unique_ptr<base::SharedMemory> shm) {
+  base::SharedPersistentMemoryAllocator shalloc(std::move(shm), 0,
+                                                kAllocatorName, true);
+  base::PersistentMemoryAllocator::Iterator iter(&shalloc);
+
+  base::SharedPersistentMemoryAllocator::Reference ref;
+  while ((ref = iter.GetNextOfType(kFieldTrialType)) !=
+         base::SharedPersistentMemoryAllocator::kReferenceNull) {
+    FieldTrialEntry* fte =
+        shalloc.GetAsObject<FieldTrialEntry>(ref, kFieldTrialType);
+    char* trial_name = GetTrialName(fte);
+    char* group_name = GetGroupName(fte);
+    FieldTrial* trial = CreateFieldTrial(trial_name, group_name);
+
+    if (fte->activated) {
+      // Call |group()| to mark the trial as "used" and notify observers, if
+      // any. This is useful to ensure that field trials created in child
+      // processes are properly reported in crash reports.
+      trial->group();
+    }
+  }
+}
+
 // static
-std::unique_ptr<base::SharedMemory> FieldTrialList::CopyFieldTrialStateToFlags(
+void FieldTrialList::CopyFieldTrialStateToFlags(
     const char* field_trial_handle_switch,
     base::CommandLine* cmd_line) {
+#if defined(OS_WIN)
+  // Use shared memory to pass the state if the feature is enabled, otherwise
+  // fallback to passing it via the command line as a string.
+  if (kUseSharedMemoryForFieldTrials) {
+    base::SharedMemory* shm = field_trial_allocator->shared_memory();
+
+    // HANDLE is just typedef'd to void *. We basically cast the handle into an
+    // int (uintptr_t, to be exact), stringify the int, and pass it as a
+    // command-line flag. The child process will do the reverse conversions to
+    // retrieve the handle. See http://stackoverflow.com/a/153077
+    auto uintptr_handle =
+        reinterpret_cast<uintptr_t>(shm->handle().GetHandle());
+    std::string field_trial_handle = std::to_string(uintptr_handle);
+
+    cmd_line->AppendSwitchASCII(field_trial_handle_switch, field_trial_handle);
+    return;
+  }
+#endif
+
   std::string field_trial_states;
   base::FieldTrialList::AllStatesToString(&field_trial_states);
   if (!field_trial_states.empty()) {
-// Use shared memory to pass the state if the feature is enabled, otherwise
-// fallback to passing it via the command line as a string.
-#if defined(OS_WIN)
-    if (kUseSharedMemoryForFieldTrials) {
-      std::unique_ptr<base::SharedMemory> shm(new base::SharedMemory());
-      size_t length = field_trial_states.size() + 1;
-      shm->CreateAndMapAnonymous(length);
-      memcpy(shm->memory(), field_trial_states.c_str(), length);
-
-      // HANDLE is just typedef'd to void *
-      auto uintptr_handle =
-          reinterpret_cast<std::uintptr_t>(shm->handle().GetHandle());
-      std::string field_trial_handle =
-          std::to_string(uintptr_handle) + "," + std::to_string(length);
-
-      cmd_line->AppendSwitchASCII(field_trial_handle_switch,
-                                  field_trial_handle);
-      return shm;
-    }
-#endif
     cmd_line->AppendSwitchASCII(switches::kForceFieldTrials,
                                 field_trial_states);
   }
-  return std::unique_ptr<base::SharedMemory>(nullptr);
 }
 
 // static
 FieldTrial* FieldTrialList::CreateFieldTrial(
     const std::string& name,
     const std::string& group_name) {
   DCHECK(global_);
   DCHECK_GE(name.size(), 0u);
   DCHECK_GE(group_name.size(), 0u);
   if (name.empty() || group_name.empty() || !global_)
@@ skipping 37 matching lines @@
   {
     AutoLock auto_lock(global_->lock_);
     if (field_trial->group_reported_)
       return;
     field_trial->group_reported_ = true;
   }
 
   if (!field_trial->enable_field_trial_)
     return;
 
+  if (kUseSharedMemoryForFieldTrials) {
+    FieldTrialList::UpdateFieldTrialAllocator(field_trial);

[Alexei Svitkine (slow), 2016/10/17 14:46:50]

Please make this lazy.

That is, someone could use base/ and even the FieldTrial API without ever
needing to create a child process or give it experiment state.

For those use cases, we don't want to create the shared memory eagerly because
it's wasteful. Instead, make the first call to AppendFieldTrialHandleIfNeeded()
trigger the creation of it originally and then thereafter append to it if it's
been created already.

[lawrencewu, 2016/10/19 16:21:28]

Done.

+  }
+
   global_->observer_list_->Notify(
       FROM_HERE, &FieldTrialList::Observer::OnFieldTrialGroupFinalized,
       field_trial->trial_name(), field_trial->group_name_internal());
 }
 
 // static
+void FieldTrialList::UpdateFieldTrialAllocator(FieldTrial* field_trial) {
+  // Create the allocator if not already created.
+  if (field_trial_allocator == nullptr) {
+    std::unique_ptr<base::SharedMemory> shm(new base::SharedMemory());
+    shm->CreateAndMapAnonymous(4 << 10);  // 4 KiB = one page
+
+    field_trial_allocator = new base::SharedPersistentMemoryAllocator(
+        std::move(shm), 0, kAllocatorName, false);

[bcwhite, 2016/10/14 14:23:46]

If you call

allocator->CreateTrackingHistograms(kAllocatorName);

You'll get two histograms added to UMA that report the number of allocations and
the amount of memory used.

See existing UMA.PersistentAllocator.* entries in
tools/metrics/histograms/histograms.xml.

The catch is that the "UsedPct" entry is updated only with a manual call so at
some point after all the field trials have been updated, you need to call

allocator->UpdateTrackingHistograms();

With this you'll be able to tell if your memory segment is large enough once its
out in the field.  Keep the maximum utilization under 75% and you'll be okay.

[lawrencewu, 2016/10/19 16:21:28]

asvitkine and I decided to punt on this for later, so I added a todo comment.
This feature won't be going live in this CL since it is hidden behind a boolean
anyway.

+  }
+
+  // We allocate just enough memory to fit the FTE struct, trial name, and group
+  // name.
+  FieldTrial::State trial_state;
+  field_trial->GetState(&trial_state);
+
+  std::string trial_name;
+  trial_state.trial_name.CopyToString(&trial_name);
+  size_t trial_name_size = trial_name.size() + 1;
+
+  std::string group_name;
+  trial_state.group_name.CopyToString(&group_name);
+  size_t group_name_size = group_name.size() + 1;
+
+  uint32_t trial_name_offset = sizeof(FieldTrialEntry);
+  uint32_t group_name_offset = trial_name_offset + trial_name_size;
+  size_t size = sizeof(FieldTrialEntry) + trial_name_size + group_name_size;
+
+  base::SharedPersistentMemoryAllocator::Reference ref =
+      field_trial_allocator->Allocate(size, kFieldTrialType);

[bcwhite, 2016/10/14 14:23:46]

You need to handle the failure case here.  If the field trial list exceeds the
memory size, this will return a null reference which will become nullptr down
below.  As it stands, Chrome will crash if there are too many field trials to
store -- an accident waiting to happen.

[lawrencewu, 2016/10/19 16:21:29]

Done.

+
+  char* dst = field_trial_allocator->GetAsObject<char>(ref, kFieldTrialType);
+  FieldTrialEntry fte = {trial_state.activated, group_name_offset};
+  memcpy(dst, &fte, sizeof(FieldTrialEntry));
+  memcpy(dst + trial_name_offset, trial_name.c_str(), trial_name_size);
+  memcpy(dst + group_name_offset, group_name.c_str(), group_name_size);
+
+  field_trial_allocator->MakeIterable(ref);
+}
+
+// static
 size_t FieldTrialList::GetFieldTrialCount() {
   if (!global_)
     return 0;
   AutoLock auto_lock(global_->lock_);
   return global_->registered_.size();
 }
 
 // static
 const FieldTrial::EntropyProvider*
     FieldTrialList::GetEntropyProviderForOneTimeRandomization() {
@@ skipping 19 matching lines @@
     return;
   }
   AutoLock auto_lock(global_->lock_);
   CHECK(!global_->PreLockedFind(trial->trial_name())) << trial->trial_name();
   trial->AddRef();
   trial->SetTrialRegistered();
   global_->registered_[trial->trial_name()] = trial;
 }
 
 }  // namespace base