Use acquire/relase for delayed persistent allocations.

base/metrics/persistent_memory_allocator.cc

 // Copyright (c) 2015 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/persistent_memory_allocator.h"
 
 #include <assert.h>
 #include <algorithm>
 
 #if defined(OS_WIN)
@@ skipping 1115 matching lines @@
   DCHECK_NE(0U, type_);
   DCHECK_LT(0U, size_);
   DCHECK(reference_);
 }
 
 DelayedPersistentAllocation::~DelayedPersistentAllocation() {}
 
 void* DelayedPersistentAllocation::Get() const {
   // Relaxed operations are acceptable here because it's not protecting the
   // contents of the allocation in any way.
-  Reference ref = reference_->load(std::memory_order_relaxed);
+  Reference ref = reference_->load(std::memory_order_acquire);
   if (!ref) {
     ref = allocator_->Allocate(size_, type_);
     if (!ref)
       return nullptr;
 
     // Store the new reference in its proper location using compare-and-swap.
     // Use a "strong" exchange to ensure no false-negatives since the operation
     // cannot be retried.
     Reference existing = 0;  // Must be mutable; receives actual value.
     if (reference_->compare_exchange_strong(existing, ref,
-                                            std::memory_order_relaxed,
+                                            std::memory_order_release,
                                             std::memory_order_relaxed)) {
       if (make_iterable_)
         allocator_->MakeIterable(ref);
     } else {
       // Failure indicates that something else has raced ahead, performed the
       // allocation, and stored its reference. Purge the allocation that was
       // just done and use the other one instead.
       DCHECK_EQ(type_, allocator_->GetType(existing));
       DCHECK_LE(size_, allocator_->GetAllocSize(existing));
       allocator_->ChangeType(ref, 0, type_, /*clear=*/false);
       ref = existing;
     }
   }
 
   char* mem = allocator_->GetAsArray<char>(ref, type_, size_);
   if (!mem) {
     // This should never happen but be tolerant if it does as corruption from
     // the outside is something to guard against.
     NOTREACHED();
     return nullptr;
   }
   return mem + offset_;
 }
 
 }  // namespace base