Add discardable memory emulation for non-android/mac platforms

base/memory/discardable_memory_provider.cc

+// Copyright 2013 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_memory_provider.h"
+
+#include "base/bind.h"
+#include "base/containers/hash_tables.h"
+#include "base/containers/mru_cache.h"
+#include "base/debug/trace_event.h"
+#include "base/memory/discardable_memory.h"
+#include "base/synchronization/lock.h"
+#include "base/sys_info.h"
+
+namespace base {
+namespace internal {
+
+namespace {
+
+// If this is given a valid value via SetInstanceForTest, this pointer will be
+// returned by GetInstance rather than the usual singleton.
+static DiscardableMemoryProvider* s_provider_for_test = NULL;
+
+// This is admittedly pretty magical. It's approximately enough memory for two
+// 2560x1600 images.
+static const size_t kDefaultDiscardableMemoryLimit = 32 * 1024 * 1024;
+static const size_t kDefaultBytesToReclaimUnderModeratePressure =
+    kDefaultDiscardableMemoryLimit / 2;
+
+}  // namespace
+
+DiscardableMemoryProvider::DiscardableMemoryProvider()
+    : allocations_(AllocationMap::NO_AUTO_EVICT),
+      bytes_allocated_(0),
+      discardable_memory_limit_(kDefaultDiscardableMemoryLimit),
+      bytes_to_reclaim_under_moderate_pressure_(
+          kDefaultBytesToReclaimUnderModeratePressure),
+      memory_pressure_listener_(
+          base::Bind(&DiscardableMemoryProvider::NotifyMemoryPressure)) {
+}
+
+DiscardableMemoryProvider::~DiscardableMemoryProvider() {
+  DCHECK_EQ(0u, allocations_.size());

[willchan no longer on Chromium, 2013/10/21 18:30:27]

DCHECK(allocations_.empty()); size() is linear in the container's size, as per
http://www.sgi.com/tech/stl/Container.html.

[reveman, 2013/10/22 00:11:42]

Done.

+  DCHECK_EQ(0u, bytes_allocated_);
+}
+
+// static
+DiscardableMemoryProvider* DiscardableMemoryProvider::GetInstance() {
+  if (s_provider_for_test)
+    return s_provider_for_test;
+  return Singleton<DiscardableMemoryProvider>::get();
+}
+
+// static
+void DiscardableMemoryProvider::SetInstanceForTest(
+    DiscardableMemoryProvider* provider) {
+  s_provider_for_test = provider;
+}
+
+// static
+void DiscardableMemoryProvider::NotifyMemoryPressure(
+    MemoryPressureListener::MemoryPressureLevel pressure_level) {
+  switch (pressure_level) {
+    case MemoryPressureListener::MEMORY_PRESSURE_MODERATE:
+      DiscardableMemoryProvider::GetInstance()->Purge();
+      return;
+    case MemoryPressureListener::MEMORY_PRESSURE_CRITICAL:
+      DiscardableMemoryProvider::GetInstance()->PurgeAll();
+      return;
+  }
+
+  NOTREACHED();
+}
+
+void DiscardableMemoryProvider::SetDiscardableMemoryLimit(size_t bytes) {
+  AutoLock lock(lock_);
+  discardable_memory_limit_ = bytes;
+  EnforcePolicy();
+}
+
+void DiscardableMemoryProvider::SetBytesToReclaimUnderModeratePressure(
+    size_t bytes) {
+  AutoLock lock(lock_);
+  bytes_to_reclaim_under_moderate_pressure_ = bytes;
+  EnforcePolicy();
+}
+
+void DiscardableMemoryProvider::Register(
+    const DiscardableMemory* discardable, size_t bytes) {
+  AutoLock lock(lock_);
+  DCHECK(allocations_.Peek(discardable) == allocations_.end());
+  allocations_.Put(discardable, Allocation(bytes));
+}
+
+void DiscardableMemoryProvider::Unregister(
+    const DiscardableMemory* discardable) {
+  AutoLock lock(lock_);
+  AllocationMap::iterator it = allocations_.Peek(discardable);
+  if (it == allocations_.end())
+    return;
+
+  if (it->second.memory) {
+    size_t bytes = it->second.bytes;
+    DCHECK_LE(bytes, bytes_allocated_);
+    bytes_allocated_ -= bytes;
+    free(it->second.memory);
+  }
+  allocations_.Erase(it);
+}
+
+scoped_ptr<uint8, FreeDeleter> DiscardableMemoryProvider::Acquire(
+    const DiscardableMemory* discardable,
+    bool* purged) {
+  AutoLock lock(lock_);
+  // NB: |allocations_| is an MRU cache, and use of |Get| here updates that
+  // cache.
+  AllocationMap::iterator it = allocations_.Get(discardable);
+  CHECK(it != allocations_.end());
+
+  if (it->second.memory) {
+    scoped_ptr<uint8, FreeDeleter> memory(it->second.memory);
+    it->second.memory = NULL;
+    *purged = false;
+    return memory.Pass();
+  }
+
+  size_t bytes = it->second.bytes;
+  if (!bytes)
+    return scoped_ptr<uint8, FreeDeleter>();
+
+  if (discardable_memory_limit_) {
+    if (bytes > discardable_memory_limit_)

[willchan no longer on Chromium, 2013/10/21 21:29:12]

I'm confused. The comment for this variable says:
  // The maximum number of bytes of discardable memory that may be allocated
  // before we assume moderate memory pressure.

Why does this mean that we should fail to acquire DiscardableMemory?

[reveman, 2013/10/22 00:11:42]

Talked to vollick@ and I don't think we should have this fail unless malloc
fails. Latest patch tries to reduce the memory usage if needed but doesn't fail.

+      return scoped_ptr<uint8, FreeDeleter>();
+
+    size_t limit = discardable_memory_limit_ - bytes;
+    PurgeLRU(limit);
+
+    if (bytes_allocated_ > limit)
+      return scoped_ptr<uint8, FreeDeleter>();
+  }
+
+  bytes_allocated_ += bytes;
+  *purged = true;
+  return scoped_ptr<uint8, FreeDeleter>(static_cast<uint8*>(malloc(bytes)));
+}
+
+void DiscardableMemoryProvider::Release(
+    const DiscardableMemory* discardable,
+    scoped_ptr<uint8, FreeDeleter> memory) {
+  AutoLock lock(lock_);
+  // NB: |allocations_| is an MRU cache, and use of |Get| here updates that
+  // cache.
+  AllocationMap::iterator it = allocations_.Get(discardable);
+  CHECK(it != allocations_.end());
+
+  DCHECK(!it->second.memory);
+  it->second.memory = memory.release();
+
+  EnforcePolicy();
+}
+
+bool DiscardableMemoryProvider::IsRegisteredForTest(

[willchan no longer on Chromium, 2013/10/21 21:29:12]

Please order functions in the .cc file to match the .h file. This is listed in
the Chromium style guide:
http://www.chromium.org/developers/coding-style#Code_Formatting.

[reveman, 2013/10/22 00:11:42]

Done.

+    const DiscardableMemory* discardable) const {
+  AutoLock lock(lock_);
+  AllocationMap::const_iterator it = allocations_.Peek(discardable);
+  return it != allocations_.end();
+}
+
+bool DiscardableMemoryProvider::CanBePurgedForTest(
+    const DiscardableMemory* discardable) const {
+  AutoLock lock(lock_);
+  AllocationMap::const_iterator it = allocations_.Peek(discardable);
+  return it != allocations_.end() && it->second.memory;
+}
+
+size_t DiscardableMemoryProvider::GetBytesAllocatedForTest() const {
+  AutoLock lock(lock_);
+  return bytes_allocated_;
+}
+
+void DiscardableMemoryProvider::PurgeLRU(size_t limit) {
+  TRACE_EVENT1("base", "DiscardableMemoryProvider::PurgeLRU", "limit", limit);
+
+  lock_.AssertAcquired();

[willchan no longer on Chromium, 2013/10/21 21:29:12]

Sometimes people use a naming convention to make it more obvious to readers
which functions expect "the" lock to already be held. Locked() or _Locked() as
the suffix can accomplish this. This makes it easier when reading a function
body to see that a lock is held prior to calling a Locked() function. Right now,
I have to read ahead to the called function body to see what its expectations
are. Up to you though.

[reveman, 2013/10/22 00:11:42]

Added "WithLockAcquired" to the name of the functions that require the lock to
be held when called.

+
+  for (AllocationMap::reverse_iterator it = allocations_.rbegin();
+       it != allocations_.rend();
+       ++it) {
+    if (bytes_allocated_ <= limit)
+      break;
+    if (!it->second.memory)
+      continue;
+
+    size_t bytes = it->second.bytes;
+    DCHECK_LE(bytes, bytes_allocated_);
+    bytes_allocated_ -= bytes;
+    free(it->second.memory);
+    it->second.memory = NULL;
+  }
+}
+
+void DiscardableMemoryProvider::Purge() {
+  AutoLock lock(lock_);
+
+  if (bytes_to_reclaim_under_moderate_pressure_ == 0)
+    return;
+
+  size_t limit = 0;
+  if (bytes_to_reclaim_under_moderate_pressure_ < discardable_memory_limit_)
+    limit = bytes_allocated_ - bytes_to_reclaim_under_moderate_pressure_;
+
+  PurgeLRU(limit);
+}
+
+void DiscardableMemoryProvider::PurgeAll() {
+  AutoLock lock(lock_);
+  PurgeLRU(0);
+}
+
+void DiscardableMemoryProvider::EnforcePolicy() {
+  lock_.AssertAcquired();
+
+  bool exceeded_bound = bytes_allocated_ > discardable_memory_limit_;
+  if (!exceeded_bound || !bytes_to_reclaim_under_moderate_pressure_)
+    return;
+
+  size_t limit = 0;
+  if (bytes_to_reclaim_under_moderate_pressure_ < discardable_memory_limit_)
+    limit = bytes_allocated_ - bytes_to_reclaim_under_moderate_pressure_;
+
+  PurgeLRU(limit);
+}
+
+}  // namespace internal
+}  // namespace base