Re-land: base: Use MADV_REMOVE instead of ftruncate to purge discardable memory segments.

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)
-#include <unistd.h>
+#if defined(OS_POSIX) && !defined(OS_NACL)

[danakj, 2015/10/20 18:04:03]

I'm still kinda uncomfortable with this statement being POSIX but the #define
being LINUX||ANDROID.

POSIX includes a lot more platforms than mac|linux|android.

Could this maybe be #if defined(DISCARDABLE..REMOVE) || defined(OS_MAC)?

Or can you leave a comment explaining why POSIX is really right here?

[reveman, 2015/10/21 14:50:57]

madvise() is part of the POSIX standard. It was added as posix_madvise() but
madvise() is what everyone seem to still use and implement. Added a comment to
explain what this include is for.

+#include <sys/mman.h>
 #endif
 
 #include <algorithm>
 
 #include "base/atomicops.h"
 #include "base/bits.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/process/process_metrics.h"
 
 #if defined(OS_ANDROID)
 #include "third_party/ashmem/ashmem.h"
 #endif
 
+// Use MADV_FREE when MADV_REMOVE is not available. MADV_FREE doesn't give us

[Primiano Tucci (use gerrit), 2015/10/20 13:33:39]

I'd probably make this comment a bit more explicit, something like:
- say explicitly that this is for mac.
- the problem is not that the page is not zero-filled, rather that it gets
purged lazily.

[reveman, 2015/10/21 14:50:57]

Done.

+// the guarantee that pages will be zero-filled after a call which makes it
+// hard to test but it shouldn't hurt to use it. Worst case, it has the effect
+// of not calling madvise.
+#if !defined(DISCARDABLE_SHARED_MEMORY_REMOVE)
+#define MADV_REMOVE MADV_FREE
+#endif
+
 namespace base {
 namespace {
 
 // Use a machine-sized pointer as atomic type. It will use the Atomic32 or
 // Atomic64 routines, depending on the architecture.
 typedef intptr_t AtomicType;
 typedef uintptr_t UAtomicType;
 
 // Template specialization for timestamp serialization/deserialization. This
 // is used to serialize timestamps using Unix time on systems where AtomicType
@@ skipping 261 matching lines @@
 }
 
 void* DiscardableSharedMemory::memory() const {
   return reinterpret_cast<uint8*>(shared_memory_.memory()) +
          AlignToPageSize(sizeof(SharedState));
 }
 
 bool DiscardableSharedMemory::Purge(Time current_time) {
   // Calls to this function must be synchronized properly.
   DFAKE_SCOPED_LOCK(thread_collision_warner_);
-
-  // Early out if not mapped. This can happen if the segment was previously
-  // unmapped using a call to Close().
-  if (!shared_memory_.memory())
-    return true;
+  DCHECK(shared_memory_.memory());
 
   SharedState old_state(SharedState::UNLOCKED, last_known_usage_);
   SharedState new_state(SharedState::UNLOCKED, Time());
   SharedState result(subtle::Acquire_CompareAndSwap(
       &SharedStateFromSharedMemory(shared_memory_)->value.i,
       old_state.value.i,
       new_state.value.i));
 
   // Update |last_known_usage_| to |current_time| if the memory is locked. This
   // allows the caller to determine if purging failed because last known usage
   // 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;
   }
 
+#if defined(OS_POSIX) && !defined(OS_NACL)
+  // Advise the kernel to remove resources associated with purged pages.
+  // Subsequent accesses of memory pages will succeed, but will result in
+  // zero-fill-on-demand pages.
+  if (madvise(reinterpret_cast<char*>(shared_memory_.memory()) +
+                  AlignToPageSize(sizeof(SharedState)),
+              AlignToPageSize(mapped_size_), MADV_REMOVE)) {
+    DPLOG(ERROR) << "madvise(MADV_REMOVE) failed";

[Primiano Tucci (use gerrit), 2015/10/20 13:33:39]

On mac if this fails you will say that madvise(MADV_REMOVE) failed, but in
reality you did a madv(MADV_FREE)
Probably better to not mention "MADV_REMOVE" from the log message here, just for
the sake of  making the error message on Mac less cryptic.

[reveman, 2015/10/21 14:50:57]

Done.

+  }
+#endif
+
   last_known_usage_ = Time();
   return true;
 }
 
 bool DiscardableSharedMemory::IsMemoryResident() const {
   DCHECK(shared_memory_.memory());
 
   SharedState result(subtle::NoBarrier_Load(
       &SharedStateFromSharedMemory(shared_memory_)->value.i));
 
   return result.GetLockState() == SharedState::LOCKED ||
          !result.GetTimestamp().is_null();
 }
 
 bool DiscardableSharedMemory::IsMemoryLocked() const {
   DCHECK(shared_memory_.memory());
 
   SharedState result(subtle::NoBarrier_Load(
       &SharedStateFromSharedMemory(shared_memory_)->value.i));
 
   return result.GetLockState() == SharedState::LOCKED;
 }
 
 void DiscardableSharedMemory::Close() {
   shared_memory_.Close();
 }
 
-#if defined(DISCARDABLE_SHARED_MEMORY_SHRINKING)
-void DiscardableSharedMemory::Shrink() {
-#if defined(OS_POSIX)
-  SharedMemoryHandle handle = shared_memory_.handle();
-  if (!SharedMemory::IsHandleValid(handle))
-    return;
-
-  // Truncate shared memory to size of SharedState.
-  if (HANDLE_EINTR(ftruncate(SharedMemory::GetFdFromSharedMemoryHandle(handle),
-                             AlignToPageSize(sizeof(SharedState)))) != 0) {
-    DPLOG(ERROR) << "ftruncate() failed";
-    return;
-  }
-  mapped_size_ = 0;
-#else
-  NOTIMPLEMENTED();
-#endif
-}
-#endif
-
 Time DiscardableSharedMemory::Now() const {
   return Time::Now();
 }
 
 }  // namespace base