NoBarrier_Load()/NoBarrier_Store() for manipulating activated field.

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 708 matching lines @@
   FieldTrialAllocator::Iterator mem_iter(allocator);
   FieldTrial::FieldTrialRef ref;
   while ((ref = mem_iter.GetNextOfType(kFieldTrialType)) !=
          SharedPersistentMemoryAllocator::kReferenceNull) {
     const FieldTrial::FieldTrialEntry* entry =
         allocator->GetAsObject<const FieldTrial::FieldTrialEntry>(
             ref, kFieldTrialType);
 
     StringPiece trial_name;
     StringPiece group_name;
-    if (entry->activated &&
+    if (subtle::NoBarrier_Load(&entry->activated) &&
         entry->GetTrialAndGroupName(&trial_name, &group_name)) {
       FieldTrial::ActiveGroup group;
       group.trial_name = trial_name.as_string();
       group.group_name = group_name.as_string();
       active_groups->push_back(group);
     }
   }
 }
 
 // static
@@ skipping 336 matching lines @@
     // Write a new entry, minus the params.
     Pickle pickle;
     pickle.WriteString(trial_name);
     pickle.WriteString(group_name);
     size_t total_size = sizeof(FieldTrial::FieldTrialEntry) + pickle.size();
     FieldTrial::FieldTrialRef new_ref =
         allocator->Allocate(total_size, kFieldTrialType);
     FieldTrial::FieldTrialEntry* new_entry =
         allocator->GetAsObject<FieldTrial::FieldTrialEntry>(new_ref,
                                                             kFieldTrialType);
+    // Note: No need to use NoBarrier ops below because this is the browser
+    // process so the value we're reading won't change underneath us and the new
+    // entry we're assigning to is not iterable yet.
     new_entry->activated = prev_entry->activated;

[bcwhite, 2016/12/13 13:38:50]

These need to be accessed using atomic ops or you're likely to get a "linter" or
"sanitizer" complaining about non-atomic operations on an atomic variable,
either now or in the future.

[Alexei Svitkine (slow), 2016/12/13 15:26:04]

Done.

     new_entry->pickle_size = pickle.size();
 
     // TODO(lawrencewu): Modify base::Pickle to be able to write over a section
     // in memory, so we can avoid this memcpy.
     char* dst = reinterpret_cast<char*>(new_entry) +
                 sizeof(FieldTrial::FieldTrialEntry);
     memcpy(dst, pickle.data(), pickle.size());
 
     // Update the ref on the field trial and add it to the list to be made
     // iterable.
@@ skipping 82 matching lines @@
     StringPiece group_name;
     if (!entry->GetTrialAndGroupName(&trial_name, &group_name))
       return false;
 
     // TODO(lawrencewu): Convert the API for CreateFieldTrial to take
     // StringPieces.
     FieldTrial* trial =
         CreateFieldTrial(trial_name.as_string(), group_name.as_string());
 
     trial->ref_ = ref;
-    if (entry->activated) {
+    if (subtle::NoBarrier_Load(&entry->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();
     }
   }
   return true;
 }
 
 #if !defined(OS_NACL)
@@ skipping 71 matching lines @@
   size_t total_size = sizeof(FieldTrial::FieldTrialEntry) + pickle.size();
   FieldTrial::FieldTrialRef ref =
       allocator->Allocate(total_size, kFieldTrialType);
   if (ref == FieldTrialAllocator::kReferenceNull) {
     NOTREACHED();
     return;
   }
 
   FieldTrial::FieldTrialEntry* entry =
       allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref, kFieldTrialType);
+  // Note: The entry isn't iterable yet, so no need to use NoBarrier_Store().
   entry->activated = trial_state.activated;

[bcwhite, 2016/12/13 13:38:50]

Still need to so "linters" and "sanitizers" won't complain.

[Alexei Svitkine (slow), 2016/12/13 15:26:04]

Done.

   entry->pickle_size = pickle.size();
 
   // TODO(lawrencewu): Modify base::Pickle to be able to write over a section in
   // memory, so we can avoid this memcpy.
   char* dst =
       reinterpret_cast<char*>(entry) + sizeof(FieldTrial::FieldTrialEntry);
   memcpy(dst, pickle.data(), pickle.size());
 
   allocator->MakeIterable(ref);
   field_trial->ref_ = ref;
@@ skipping 14 matching lines @@
     // yet -- it'll just return early.
     AddToAllocatorWhileLocked(global_->field_trial_allocator_.get(),
                               field_trial);
   } else {
     // It's also okay to do this even though the callee doesn't have a lock --
     // the only thing that happens on a stale read here is a slight performance
     // hit from the child re-synchronizing activation state.
     FieldTrial::FieldTrialEntry* entry =
         allocator->GetAsObject<FieldTrial::FieldTrialEntry>(ref,
                                                             kFieldTrialType);
-    entry->activated = true;
+    subtle::NoBarrier_Store(&entry->activated, 1);
   }
 }
 
 // static
 const FieldTrial::EntropyProvider*
     FieldTrialList::GetEntropyProviderForOneTimeRandomization() {
   if (!global_) {
     used_without_global_ = true;
     return NULL;
   }
@@ skipping 15 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