[Discardable Shared Memory] Adding Windows support.

base/memory/discardable_shared_memory.cc

 // Copyright 2014 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/memory/discardable_shared_memory.h"
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 // For madvise() which is available on all POSIX compatible systems.
 #include <sys/mman.h>
 #endif
@@ skipping 196 matching lines @@
   locked_page_count_ += end - start;
 #if DCHECK_IS_ON()
   // Detect incorrect usage by keeping track of exactly what pages are locked.
   for (auto page = start; page < end; ++page) {
     auto result = locked_pages_.insert(page);
     DCHECK(result.second);
   }
   DCHECK_EQ(locked_pages_.size(), locked_page_count_);
 #endif
 
+// Pin pages if supported.
 #if defined(OS_ANDROID)
   SharedMemoryHandle handle = shared_memory_.handle();
   if (SharedMemory::IsHandleValid(handle)) {
     if (ashmem_pin_region(
             handle.fd, AlignToPageSize(sizeof(SharedState)) + offset, length)) {
       return PURGED;
     }
   }
+#elif defined(OS_WIN)
+  // If osVersion is 0, we need to lazy init.
+  if ((osVersion >= base::win::VERSION_WIN8) ||
+      ((!osVersion) &&
+       ((osVersion = base::win::GetVersion()) >= base::win::VERSION_WIN8))) {

[reveman, 2015/11/05 19:13:47]

I'm not a fan of this. It's hard to read. There's a race condition as this is
called on multiple threads [1] and the hard-to-read logic is duplicated below.

[1] it's a subtle race condition that won't cause harm but we avoid this in
chromium afaik. we should be using LazyInstance if we need to cache this value.

[penny, 2015/11/05 19:51:29]

Bruce, Justin and I don't feel strongly about this, so I've reverted to just
referencing the OSInfo version every call to Lock/Unlock.  Both implementations
will be quite close in efficiency after optimizations.

+    if (!VirtualAlloc(reinterpret_cast<char*>(shared_memory_.memory()) +
+                          AlignToPageSize(sizeof(SharedState)) + offset,
+                      length, MEM_RESET_UNDO, PAGE_READWRITE)) {
+      return PURGED;
+    }
+  }
 #endif
 
   return SUCCESS;
 }
 
 void DiscardableSharedMemory::Unlock(size_t offset, size_t length) {
   DCHECK_EQ(AlignToPageSize(offset), offset);
   DCHECK_EQ(AlignToPageSize(length), length);
 
   // Calls to this function must be synchronized properly.
   DFAKE_SCOPED_LOCK(thread_collision_warner_);
 
   // Zero for length means "everything onward".
   if (!length)
     length = AlignToPageSize(mapped_size_) - offset;
 
   DCHECK(shared_memory_.memory());
 
+// Unpin pages if supported.
 #if defined(OS_ANDROID)
   SharedMemoryHandle handle = shared_memory_.handle();
   if (SharedMemory::IsHandleValid(handle)) {
     if (ashmem_unpin_region(
             handle.fd, AlignToPageSize(sizeof(SharedState)) + offset, length)) {
       DPLOG(ERROR) << "ashmem_unpin_region() failed";
     }
   }
+#elif defined(OS_WIN)
+  // If osVersion is 0, we need to lazy init.
+  if ((osVersion >= base::win::VERSION_WIN8) ||
+      ((!osVersion) &&
+       ((osVersion = base::win::GetVersion()) >= base::win::VERSION_WIN8))) {
+    // Note: MEM_RESET is not technically gated on Win8.  However, this Unlock
+    // function needs to match the Lock behaviour (MEM_RESET_UNDO) to properly
+    // implement memory pinning.  It needs to bias towards preserving the
+    // contents of memory between an Unlock and next Lock.
+    if (!VirtualAlloc(reinterpret_cast<char*>(shared_memory_.memory()) +
+                          AlignToPageSize(sizeof(SharedState)) + offset,
+                      length, MEM_RESET, PAGE_READWRITE)) {
+      DPLOG(ERROR) << "VirtualAlloc() MEM_RESET failed in Unlock()";
+    }
+  }
 #endif
 
   size_t start = offset / base::GetPageSize();
   size_t end = start + length / base::GetPageSize();
   DCHECK_LT(start, end);
   DCHECK_LE(end, AlignToPageSize(mapped_size_) / base::GetPageSize());
 
   // Remove pages from |locked_page_count_|.
   // Note: Unlocking a page that is not locked is an error.
   DCHECK_GE(locked_page_count_, end - start);
@@ skipping 55 matching lines @@
   // was incorrect or memory was locked. In the second case, the caller should
   // most likely wait for some amount of time before attempting to purge the
   // the memory again.
   if (result.value.u != old_state.value.u) {
     last_known_usage_ = result.GetLockState() == SharedState::LOCKED
                             ? current_time
                             : result.GetTimestamp();
     return false;
   }
 
+// The next section will release as much resource as can be done
+// from the purging process, until the client process notices the
+// purge and releases its own references.
+// Note: this memory will not be accessed again.  The segment will be
+// freed asynchronously at a later time, so just do the best
+// immediately.
 #if defined(OS_POSIX) && !defined(OS_NACL)
 // Linux and Android provide MADV_REMOVE which is preferred as it has a
 // behavior that can be verified in tests. Other POSIX flavors (MacOSX, BSDs),
 // provide MADV_FREE which has the same result but memory is purged lazily.
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 #define MADV_PURGE_ARGUMENT MADV_REMOVE
 #else
 #define MADV_PURGE_ARGUMENT MADV_FREE
 #endif
   // Advise the kernel to remove resources associated with purged pages.
   // Subsequent accesses of memory pages will succeed, but might result in
   // zero-fill-on-demand pages.
   if (madvise(reinterpret_cast<char*>(shared_memory_.memory()) +
                   AlignToPageSize(sizeof(SharedState)),
               AlignToPageSize(mapped_size_), MADV_PURGE_ARGUMENT)) {
     DPLOG(ERROR) << "madvise() failed";
   }
+#elif defined(OS_WIN)
+  // MEM_DECOMMIT the purged pages to release the physical storage,
+  // either in memory or in the paging file on disk.  Pages remain RESERVED.
+  if (!VirtualFree(reinterpret_cast<char*>(shared_memory_.memory()) +
+                       AlignToPageSize(sizeof(SharedState)),
+                   AlignToPageSize(mapped_size_), MEM_DECOMMIT)) {
+    DPLOG(ERROR) << "VirtualFree() MEM_DECOMMIT failed in Purge()";
+  }
 #endif
 
   last_known_usage_ = Time();
   return true;
 }
 
 bool DiscardableSharedMemory::IsMemoryResident() const {
   DCHECK(shared_memory_.memory());
 
   SharedState result(subtle::NoBarrier_Load(
@@ skipping 13 matching lines @@
 }
 
 void DiscardableSharedMemory::Close() {
   shared_memory_.Close();
 }
 
 Time DiscardableSharedMemory::Now() const {
   return Time::Now();
 }
 
+#if defined(OS_WIN)
+// Initialize our static Windows version to 0.
+// Lazy init will happen when first checked in Lock/Unlock.
+// static
+base::win::Version DiscardableSharedMemory::osVersion =
+    base::win::VERSION_PRE_XP;
+#endif
+
 }  // namespace base