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/memory/discardable_memory.h"
+#include "base/synchronization/lock.h"
+#include "base/sys_info.h"
+
+namespace base {
+
+namespace {
+
+// If this is given a valid value via SetInstanceForTest, this pointer will be
+// returned by GetInstance rather than the usual singleton.
+static base::DiscardableMemoryProvider* s_provider_for_test = NULL;
+
+// This is admittedly pretty magical. It's approximately enough memory for two
+// 2560x1600 images.

[willchan no longer on Chromium, 2013/08/27 03:23:15]

One thing I wonder is if we'll have a good way of catching new users of this API
which might lead to a resident set that exceeds the available memory and cause
too much thrashing. Will performance tests catch this? Or do we need more
controls here? Do you have any idea about how serious it is if we get this
wrong, and if we have good automated ways of catching this?

[Ian Vollick, 2013/09/24 17:15:25]

Consumers of the DiscardableMemory already need to be prepared for requests to
fail, so if we get this wrong, we shouldn't be worse than our current behavior.

As for detecting when we're doing badly, I've instrumented the purge calls with
trace events. It should be simple to build automated tests around them if this
turns out to be a pain point.

+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),
+      enforcing_policy_(false),
+      memory_pressure_listener_(
+          base::Bind(&DiscardableMemoryProvider::NotifyMemoryPressure)) {
+}
+
+DiscardableMemoryProvider::~DiscardableMemoryProvider() {
+  AutoLock lock(allocations_lock_);
+  AllocationMap::iterator it = allocations_.begin();
+  for (; it != allocations_.end(); ++it)
+    if (it->first->memory_)
+      it->first->Deallocate();
+}
+
+// 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()->PurgeLRU();
+      break;
+    case MemoryPressureListener::MEMORY_PRESSURE_CRITICAL:
+      DiscardableMemoryProvider::GetInstance()->PurgeAll();
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+void DiscardableMemoryProvider::SetDiscardableMemoryLimit(size_t bytes) {
+  {
+    AutoLock lock(bytes_allocated_lock_);
+    discardable_memory_limit_ = bytes;
+  }
+  EnforcePolicy();
+}
+
+size_t DiscardableMemoryProvider::discardable_memory_limit() const {
+  AutoLock lock(bytes_allocated_lock_);
+  return discardable_memory_limit_;
+}
+
+void DiscardableMemoryProvider::SetBytesToReclaimUnderModeratePressure(
+    size_t bytes) {
+  {
+    AutoLock lock(bytes_allocated_lock_);
+    bytes_to_reclaim_under_moderate_pressure_ = bytes;
+  }
+  EnforcePolicy();
+}
+
+size_t DiscardableMemoryProvider::
+    bytes_to_reclaim_under_moderate_pressure() const {
+  AutoLock lock(bytes_allocated_lock_);
+  return bytes_to_reclaim_under_moderate_pressure_;
+}
+
+void DiscardableMemoryProvider::Register(DiscardableMemory* discardable) {
+  DCHECK(allocations_.Peek(discardable) == allocations_.end());
+  {
+    AutoLock lock(allocations_lock_);
+    allocations_.Put(discardable, true);
+  }
+  EnforcePolicy();
+}
+
+void DiscardableMemoryProvider::Unregister(DiscardableMemory* discardable) {
+  {
+    AutoLock lock(allocations_lock_);
+    AllocationMap::iterator it = allocations_.Peek(discardable);
+    if (it != allocations_.end())
+      allocations_.Erase(it);
+  }
+  EnforcePolicy();
+}
+
+void DiscardableMemoryProvider::DidAllocate(size_t bytes) {
+  {
+    AutoLock lock(bytes_allocated_lock_);
+    bytes_allocated_ += bytes;
+  }
+  EnforcePolicy();
+}
+
+void DiscardableMemoryProvider::DidDeallocate(size_t bytes) {
+  {
+    AutoLock lock(bytes_allocated_lock_);
+    DCHECK(bytes <= bytes_allocated_);

[willchan no longer on Chromium, 2013/08/27 03:23:15]

DCHECK_LE?

[Ian Vollick, 2013/09/24 17:15:25]

Done.

+    bytes_allocated_ -= bytes;
+  }
+  EnforcePolicy();
+}
+
+bool DiscardableMemoryProvider::DidAccess(DiscardableMemory* discardable) {
+  AutoLock lock(allocations_lock_);
+  AllocationMap::iterator it = allocations_.Get(discardable);

[willchan no longer on Chromium, 2013/08/27 03:23:15]

This is non-obvious to readers who don't realize the side effect of the Get()
leading to updating the MRUCache, and it's not obvious when reading
AllocationMap that it's a MRUCache if you're just skimming the code. Can you
explain with a comment?

[Ian Vollick, 2013/09/24 17:15:25]

Done.

+  return it != allocations_.end();
+}
+
+void DiscardableMemoryProvider::PurgeAll() {
+  AutoLock lock(allocations_lock_);
+  AllocationMap::iterator it = allocations_.begin();
+  for (; it != allocations_.end(); ++it) {
+    if (it->first->memory_ && !it->first->is_locked()) {
+      it->first->Deallocate();
+      DCHECK(!it->first->memory_);
+    }
+  }
+}
+
+void DiscardableMemoryProvider::PurgeLRU() {
+  size_t limit = 0;
+  {
+    AutoLock lock(bytes_allocated_lock_);
+    if (bytes_to_reclaim_under_moderate_pressure_ == 0)
+      return;
+
+    if (bytes_to_reclaim_under_moderate_pressure_ < discardable_memory_limit_)
+      limit = bytes_allocated_ - bytes_to_reclaim_under_moderate_pressure_;
+  }
+
+  AutoLock lock(allocations_lock_);
+  AllocationMap::reverse_iterator it = allocations_.rbegin();
+  for(; it != allocations_.rend(); ++it) {
+    if (!it->first->memory_ || it->first->is_locked())
+      continue;
+    it->first->Deallocate();
+    DCHECK(!it->first->memory_);
+    AutoLock bytes_lock(bytes_allocated_lock_);
+    if (bytes_allocated_ <= limit)
+      break;
+  }
+}
+
+void DiscardableMemoryProvider::EnforcePolicy() {
+  {
+    AutoLock lock(bytes_allocated_lock_);
+    if (enforcing_policy_)
+      return;
+  }
+
+  bool exceeded_bound = false;
+  {
+    AutoLock lock(bytes_allocated_lock_);
+    enforcing_policy_ = true;
+    if (discardable_memory_limit_ == 0) {
+      enforcing_policy_ = false;
+      return;
+    }
+    exceeded_bound = bytes_allocated_ > discardable_memory_limit_;
+  }
+
+  if (exceeded_bound)
+    PurgeLRU();
+
+  {
+    AutoLock lock(bytes_allocated_lock_);
+    enforcing_policy_ = false;
+  }
+}
+
+}  // namespace base