Clear memory in a predictable and atomic manner when changing type.

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 522 matching lines @@
     // If clearing the memory, first change it to the "transitioning" type so
     // there can be no confusion by other threads. After the memory is cleared,
     // it can be changed to its final type.
     if (!block->type_id.compare_exchange_strong(
             from_type_id, kTypeIdTransitioning, std::memory_order_acquire,
             std::memory_order_acquire)) {
       // Existing type wasn't what was expected: fail (with no changes)
       return false;
     }
 
-    // Clear the memory while the type doesn't match either "from" or "to".
-    memset(const_cast<char*>(reinterpret_cast<volatile char*>(block) +
-                             sizeof(BlockHeader)),
-           0, block->size - sizeof(BlockHeader));
+    // Clear the memory in an atomic manner. Using "release" stores force
+    // every write to be done after the ones before it. This is better than
+    // using memset because (a) it supports "volatile" and (b) it creates a
+    // reliable pattern upon which other threads may rely.
+    volatile std::atomic<int>* data =
+        reinterpret_cast<volatile std::atomic<int>*>(
+            reinterpret_cast<volatile char*>(block) + sizeof(BlockHeader));
+    const uint32_t words = (block->size - sizeof(BlockHeader)) / sizeof(int);
+    DCHECK_EQ(0U, (block->size - sizeof(BlockHeader)) % sizeof(int));
+    for (uint32_t i = 0; i < words; ++i) {
+      data->store(0, std::memory_order_release);
+      ++data;
+    }
 
     // If the destination type is "transitioning" then skip the final exchange.
     if (to_type_id == kTypeIdTransitioning)
       return true;
 
     // Finish the change to the desired type.
     from_type_id = kTypeIdTransitioning;  // Exchange needs modifiable original.
     bool success = block->type_id.compare_exchange_strong(
         from_type_id, to_type_id, std::memory_order_release,
         std::memory_order_relaxed);
@@ skipping 429 matching lines @@
 
 // static
 bool FilePersistentMemoryAllocator::IsFileAcceptable(
     const MemoryMappedFile& file,
     bool read_only) {
   return IsMemoryAcceptable(file.data(), file.length(), 0, read_only);
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace base